LayoutLM

概述

LayoutLM 模型在 Yiheng Xu、Minghao Li、Lei Cui、Shaohan Huang、Furu Wei 和 Ming Zhou 的論文 LayoutLM: Pre-training of Text and Layout for Document Image Understanding 中提出。它是一種簡單而有效的文字和佈局預訓練方法，用於文件影像理解和資訊提取任務，例如表單理解和收據理解。它在以下幾個下游任務中獲得了最先進的結果：

表單理解：FUNSD 資料集（包含 199 個帶註釋的表單，超過 30,000 個單詞）。
收據理解：SROIE 資料集（包含 626 張用於訓練的收據和 347 張用於測試的收據）。
文件影像分類：RVL-CDIP 資料集（包含 400,000 張影像，屬於 16 個類別之一）。

論文摘要如下：

近年來，預訓練技術已在各種 NLP 任務中成功驗證。儘管預訓練模型廣泛應用於 NLP 應用程式，但它們幾乎只關注文字級操作，而忽略了對於文件影像理解至關重要的佈局和樣式資訊。在本文中，我們提出了 LayoutLM，用於聯合建模掃描文件影像中文字和佈局資訊之間的互動，這對於大量的現實世界文件影像理解任務（如從掃描文件中提取資訊）非常有利。此外，我們還利用影像特徵將單詞的視覺資訊融入 LayoutLM。據我們所知，這是首次將文字和佈局在一個單一框架中聯合學習用於文件級預訓練。它在多項下游任務中取得了新的最先進結果，包括表單理解（從 70.72 提高到 79.27）、收據理解（從 94.02 提高到 95.24）和文件影像分類（從 93.07 提高到 94.42）。

使用技巧

除了 input_ids，forward() 還期望輸入 bbox，它們是輸入 token 的邊界框（即 2D 位置）。這些可以透過外部 OCR 引擎（如 Google 的 Tesseract，有一個可用的 Python 封裝）獲得。每個邊界框都應採用 (x0, y0, x1, y1) 格式，其中 (x0, y0) 對應於邊界框左上角的位置，(x1, y1) 表示右下角的位置。請注意，首先需要將邊界框歸一化到 0-1000 比例。要進行歸一化，可以使用以下函式：

def normalize_bbox(bbox, width, height):
    return [
        int(1000 * (bbox[0] / width)),
        int(1000 * (bbox[1] / height)),
        int(1000 * (bbox[2] / width)),
        int(1000 * (bbox[3] / height)),
    ]

其中，width 和 height 對應於原始文件的寬度和高度，token 位於其中。例如，這些可以使用 Python 影像庫 (PIL) 庫獲得，如下所示：

from PIL import Image

# Document can be a png, jpg, etc. PDFs must be converted to images.
image = Image.open(name_of_your_document).convert("RGB")

width, height = image.size

資源

官方 Hugging Face 和社群（由 🌎 表示）資源列表，幫助您開始使用 LayoutLM。如果您有興趣提交資源以供此處收錄，請隨時提出拉取請求，我們將對其進行審查！該資源應理想地展示一些新內容，而不是重複現有資源。

文件問答

關於使用 Keras 和 Hugging Face Transformers 對 LayoutLM 進行文件理解微調的部落格文章。
關於僅使用 Hugging Face Transformers 對 LayoutLM 進行文件理解微調的部落格文章。
關於使用影像嵌入在 FUNSD 資料集上對 LayoutLM 進行微調的筆記本。
另請參閱：文件問答任務指南

文字分類

關於在 RVL-CDIP 資料集上對 LayoutLM 進行序列分類微調的筆記本。
文字分類任務指南

Token 分類

關於在 FUNSD 資料集上對 LayoutLM 進行 token 分類微調的筆記本。
Token分類任務指南

其他資源

掩碼語言建模任務指南

🚀 部署

關於使用 Hugging Face 推理端點部署 LayoutLM的部落格文章。

LayoutLMConfig

class transformers.LayoutLMConfig

< 來源 >

( 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 position_embedding_type = 'absolute' use_cache = True max_2d_position_embeddings = 1024 **kwargs )

引數

vocab_size (int, 可選, 預設為 30522) — LayoutLM 模型的詞彙表大小。定義了可以透過 LayoutLMModel 的 forward 方法傳遞的 inputs_ids 所能表示的不同 token。
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"、"silu" 和 "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) — 傳遞給 LayoutLMModel 的 token_type_ids 的詞彙表大小。
initializer_range (float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的 truncated_normal_initializer 的標準差。
layer_norm_eps (float, 可選, 預設為 1e-12) — 層歸一化層使用的 epsilon。
pad_token_id (int, 可選, 預設為 0) — 用於填充 input_ids 的值。
position_embedding_type (str, 可選, 預設為 "absolute") — 位置嵌入的型別。選擇 "absolute"、"relative_key"、"relative_key_query" 之一。對於位置嵌入，請使用 "absolute"。有關 "relative_key" 的更多資訊，請參閱 Self-Attention with Relative Position Representations (Shaw et al.)。有關 "relative_key_query" 的更多資訊，請參閱 Improve Transformer Models with Better Relative Position Embeddings (Huang et al.) 中的方法 4。
use_cache (bool, 可選, 預設為 True) — 模型是否應返回最後的鍵/值注意力（並非所有模型都使用）。僅當 config.is_decoder=True 時相關。
max_2d_position_embeddings (int, 可選, 預設為 1024) — 2D 位置嵌入可能使用的最大值。通常設定為較大值以防萬一（例如 1024）。

這是用於儲存 LayoutLMModel 配置的配置類。它用於根據指定引數例項化 LayoutLM 模型，定義模型架構。使用預設值例項化配置將產生類似於 LayoutLM microsoft/layoutlm-base-uncased 架構的配置。

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

示例

>>> from transformers import LayoutLMConfig, LayoutLMModel

>>> # Initializing a LayoutLM configuration
>>> configuration = LayoutLMConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = LayoutLMModel(configuration)

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

LayoutLMTokenizer

class transformers.LayoutLMTokenizer

< 來源 >

( vocab_file do_lower_case = True do_basic_tokenize = True never_split = None unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None clean_up_tokenization_spaces = True **kwargs )

引數

vocab_file (str) — 包含詞彙表的檔案。
do_lower_case (bool, 可選, 預設為 True) — 分詞時是否將輸入小寫。
do_basic_tokenize (bool, 可選, 預設為 True) — 是否在 WordPiece 之前進行基本分詞。
never_split (Iterable, 可選) — 分詞時永不拆分的 token 集合。僅當 do_basic_tokenize=True 時有效。
unk_token (str, 可選, 預設為 "[UNK]") — 未知 token。不在詞彙表中的 token 無法轉換為 ID，而是設定為此 token。
sep_token (str, 可選, 預設為 "[SEP]") — 分隔符 token，用於從多個序列構建序列時，例如用於序列分類的兩個序列或用於問答的文字和問題。它也用作使用特殊 token 構建的序列的最後一個 token。
pad_token (str, 可選, 預設為 "[PAD]") — 用於填充的 token，例如在批處理不同長度的序列時。
cls_token (str, 可選, 預設為 "[CLS]") — 分類器 token，用於序列分類（整個序列的分類而不是按 token 分類）。使用特殊 token 構建序列時，它是序列的第一個 token。
mask_token (str, 可選, 預設為 "[MASK]") — 用於掩碼值的 token。訓練此模型進行掩碼語言建模時使用此 token。這是模型將嘗試預測的 token。
tokenize_chinese_chars (bool, 可選, 預設為 True) — 是否對中文字元進行分詞。

對於日文，這可能需要停用（請參閱此問題）。
strip_accents (bool, 可選) — 是否剝離所有重音符號。如果未指定此選項，則將由 lowercase 的值決定（與原始 LayoutLM 中相同）。
clean_up_tokenization_spaces (bool, 可選, 預設為 True) — 解碼後是否清理空格，清理包括刪除潛在的偽影，例如多餘的空格。

構建 LayoutLM 分詞器。基於 WordPiece。

此分詞器繼承自 PreTrainedTokenizer，其中包含大部分主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。

build_inputs_with_special_tokens

< source >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → List[int]

引數

token_ids_0 (List[int]) — 要新增特殊標記的ID列表。
token_ids_1 (List[int], 可選) — 序列對的第二個ID列表。

List[int]

帶有適當特殊標記的輸入ID列表。

透過連線和新增特殊標記，從一個序列或一對序列構建用於序列分類任務的模型輸入。LayoutLM序列的格式如下

單個序列：[CLS] X [SEP]
序列對：[CLS] A [SEP] B [SEP]

convert_tokens_to_string

< source >

( tokens )

將標記序列（字串）轉換為單個字串。

get_special_tokens_mask

< source >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → List[int]

引數

token_ids_0 (List[int]) — ID列表。
token_ids_1 (List[int], 可選) — 序列對的第二個ID列表。
already_has_special_tokens (bool, 可選, 預設為 False) — 標記列表是否已按模型特殊標記格式化。

List[int]

一個範圍為 [0, 1] 的整數列表：1 表示特殊標記，0 表示序列標記。

從沒有新增特殊標記的標記列表中檢索序列ID。此方法在使用分詞器prepare_for_model方法新增特殊標記時呼叫。

LayoutLMTokenizerFast

class transformers.LayoutLMTokenizerFast

< source >

( vocab_file = None tokenizer_file = None do_lower_case = True unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None **kwargs )

引數

vocab_file (str) — 包含詞彙表的檔案。
do_lower_case (bool, 可選, 預設為 True) — 標記時是否將輸入轉換為小寫。
unk_token (str, 可選, 預設為 "[UNK]") — 未知標記。不在詞彙表中的標記不能轉換為ID，而會設定為此標記。
sep_token (str, 可選, 預設為 "[SEP]") — 分隔符標記，用於從多個序列構建序列時，例如用於序列分類的兩個序列或用於問答的文字和問題。它也用作使用特殊標記構建的序列的最後一個標記。
pad_token (str, 可選, 預設為 "[PAD]") — 用於填充的標記，例如在對不同長度的序列進行批處理時。
cls_token (str, 可選, 預設為 "[CLS]") — 分類器標記，用於序列分類（整個序列的分類而非逐標記分類）。使用特殊標記構建序列時，它是序列的第一個標記。
mask_token (str, 可選, 預設為 "[MASK]") — 用於遮蓋值的標記。這是使用遮蓋語言建模訓練此模型時使用的標記。這是模型將嘗試預測的標記。
clean_text (bool, 可選, 預設為 True) — 是否在標記化之前清理文字，即刪除任何控制字元並將所有空白替換為經典空白。
tokenize_chinese_chars (bool, 可選, 預設為 True) — 是否對中文字元進行分詞。對於日文，應停用此功能（參見此問題）。
strip_accents (bool, 可選) — 是否去除所有重音符號。如果未指定此選項，則將由 lowercase 的值決定（與原始 LayoutLM 中相同）。
wordpieces_prefix (str, 可選, 預設為 "##") — 子詞的字首。

構造一個“快速”LayoutLM 分詞器（由 HuggingFace 的 tokenizers 庫支援）。基於 WordPiece。

此分詞器繼承自 PreTrainedTokenizerFast，其中包含大部分主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。

build_inputs_with_special_tokens

< source >

( token_ids_0 token_ids_1 = None ) → List[int]

引數

token_ids_0 (List[int]) — 要新增特殊標記的ID列表。
token_ids_1 (List[int], 可選) — 序列對的第二個ID列表。

List[int]

帶有適當特殊標記的輸入ID列表。

透過連線和新增特殊標記，從一個序列或一對序列構建用於序列分類任務的模型輸入。LayoutLM序列的格式如下

單個序列：[CLS] X [SEP]
序列對：[CLS] A [SEP] B [SEP]

Pytorch

隱藏 Pytorch 內容

LayoutLMModel

class transformers.LayoutLMModel

< source >

( config )

引數

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

裸LayoutLM模型，輸出原始隱藏狀態，頂部沒有任何特定頭部。

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

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

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = None bbox: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[torch.FloatTensor] = None encoder_attention_mask: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或 tuple(torch.FloatTensor)

引數

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

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

什麼是輸入 ID？
bbox (torch.LongTensor，形狀為 (batch_size, sequence_length, 4)，可選) — 每個輸入序列標記的邊界框。在 [0, config.max_2d_position_embeddings-1] 範圍內選擇。每個邊界框應為 (x0, y0, x1, y1) 格式的標準化版本，其中 (x0, y0) 對應於邊界框左上角的位置，(x1, y1) 表示右下角的位置。請參閱概述瞭解標準化。
attention_mask (torch.FloatTensor，形狀為 (batch_size, sequence_length)，可選) — 掩碼，用於避免對填充標記索引執行注意力操作。掩碼值在 [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.n_positions - 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 索引轉換為相關向量（而不是模型內部的嵌入查詢矩陣）有更多控制，這很有用。
encoder_hidden_states (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 編碼器最後一層輸出的隱藏狀態序列。如果模型配置為解碼器，則用於交叉注意力。
encoder_attention_mask (torch.FloatTensor，形狀為 (batch_size, sequence_length)，可選) — 掩碼，用於避免對編碼器輸入中的填充標記索引執行注意力操作。如果模型配置為解碼器，則此掩碼用於交叉注意力。掩碼值在 [0, 1] 之間選擇：
- 1 表示未遮蓋的標記，
- 0 表示已遮蓋的標記。
output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的 attentions。
output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量下的 hidden_states。
return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通的元組。

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

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

last_hidden_state (torch.FloatTensor, 形狀為 (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。
pooler_output (torch.FloatTensor，形狀為 (batch_size, hidden_size)) — 序列的第一個標記（分類標記）經過輔助預訓練任務所用層進一步處理後的最後一層隱藏狀態。例如，對於 BERT 家族模型，這會返回分類標記在經過線性層和 tanh 啟用函式處理後的結果。線性層權重在預訓練期間透過下一句預測（分類）目標進行訓練。
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 之後，用於計算交叉注意力頭中的加權平均。
past_key_values (Cache, 可選, 當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 Cache 例項。有關更多詳細資訊，請參閱我們的 kv 快取指南。

包含預先計算的隱藏狀態（自注意力塊中的鍵和值，如果 config.is_encoder_decoder=True，則可選地在交叉注意力塊中），可用於（參見 past_key_values 輸入）加速順序解碼。

LayoutLMModel forward 方法，覆蓋 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, LayoutLMModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])

>>> outputs = model(
...     input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids
... )

>>> last_hidden_states = outputs.last_hidden_state

LayoutLMForMaskedLM

class transformers.LayoutLMForMaskedLM

< source >

( config )

引數

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

帶有“語言建模”頭部的LayoutLM模型。”

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

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

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = None bbox: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None encoder_hidden_states: typing.Optional[torch.FloatTensor] = None encoder_attention_mask: typing.Optional[torch.FloatTensor] = 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)

引數

input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 輸入序列標記在詞彙表中的索引。預設情況下，填充將被忽略。

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

什麼是 input IDs？
bbox (torch.LongTensor of shape (batch_size, sequence_length, 4), optional) — 每個輸入序列標記的邊界框。選擇範圍為 [0, config.max_2d_position_embeddings-1]。每個邊界框都應是 (x0, y0, x1, y1) 格式的歸一化版本，其中 (x0, y0) 對應於邊界框左上角的位置，(x1, y1) 表示右下角的位置。有關歸一化，請參閱概述。
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為 [0, 1]：
- 1 表示**未被掩碼**的標記，
- 0 表示**被掩碼**的標記。
什麼是注意力掩碼？
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 片段標記索引，用於指示輸入的第一個和第二個部分。索引選擇範圍為 [0, 1]：
- 0 對應於**句子 A** 標記，
- 1 對應於**句子 B** 標記。
什麼是標記型別 ID？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每個輸入序列標記在位置嵌入中的位置索引。選擇範圍為 [0, config.n_positions - 1]。

什麼是位置 ID？
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇範圍為 [0, 1]：
- 1 表示頭部**未被掩碼**，
- 0 表示頭部**被掩碼**。
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可選地，除了傳遞 input_ids 之外，您還可以選擇直接傳遞嵌入表示。如果您希望對 input_ids 索引如何轉換為關聯向量擁有比模型內部嵌入查詢矩陣更多的控制，這會很有用。
labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用於計算掩碼語言建模損失的標籤。索引應在 [-100, 0, ..., config.vocab_size] 範圍內（請參閱 input_ids 文件字串）。索引設定為 -100 的標記將被忽略（掩碼），損失僅針對標籤在 [0, ..., config.vocab_size] 範圍內的標記計算。
encoder_hidden_states (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 編碼器最後一層輸出的隱藏狀態序列。如果模型被配置為解碼器，則用於交叉注意力。
encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用於避免在編碼器輸入填充標記索引上執行注意力操作的掩碼。如果模型被配置為解碼器，則此掩碼用於交叉注意力。掩碼值選擇範圍為 [0, 1]：
- 1 表示**未被掩碼**的標記，
- 0 表示**被掩碼**的標記。
output_attentions (bool, optional) — 是否返回所有注意力層的注意力張量。有關詳細資訊，請參閱返回張量中的 attentions。
output_hidden_states (bool, optional) — 是否返回所有層的隱藏狀態。有關詳細資訊，請參閱返回張量中的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通的元組。

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

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

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

LayoutLMForMaskedLM 的 forward 方法覆蓋了 __call__ 特殊方法。

示例

>>> from transformers import AutoTokenizer, LayoutLMForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForMaskedLM.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "[MASK]"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])

>>> labels = tokenizer("Hello world", return_tensors="pt")["input_ids"]

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=labels,
... )

>>> loss = outputs.loss

LayoutLMForSequenceClassification

class transformers.LayoutLMForSequenceClassification

< source >

( config )

引數

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

帶有序列分類頭（池化輸出頂部的線性層）的 LayoutLM 模型，例如用於文件影像分類任務，例如 RVL-CDIP 資料集。

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

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

forward

< source >

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

引數

input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 輸入序列標記在詞彙表中的索引。預設情況下，填充將被忽略。

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

什麼是 input IDs？
bbox (torch.LongTensor of shape (batch_size, sequence_length, 4), optional) — 每個輸入序列標記的邊界框。選擇範圍為 [0, config.max_2d_position_embeddings-1]。每個邊界框都應是 (x0, y0, x1, y1) 格式的歸一化版本，其中 (x0, y0) 對應於邊界框左上角的位置，(x1, y1) 表示右下角的位置。有關歸一化，請參閱概述。
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為 [0, 1]：
- 1 表示**未被掩碼**的標記，
- 0 表示**被掩碼**的標記。
什麼是注意力掩碼？
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 片段標記索引，用於指示輸入的第一個和第二個部分。索引選擇範圍為 [0, 1]：
- 0 對應於**句子 A** 標記，
- 1 對應於**句子 B** 標記。
什麼是標記型別 ID？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每個輸入序列標記在位置嵌入中的位置索引。選擇範圍為 [0, config.n_positions - 1]。

什麼是位置 ID？
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇範圍為 [0, 1]：
- 1 表示頭部**未被掩碼**，
- 0 表示頭部**被掩碼**。
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可選地，除了傳遞 input_ids 之外，您還可以選擇直接傳遞嵌入表示。如果您希望對 input_ids 索引如何轉換為關聯向量擁有比模型內部嵌入查詢矩陣更多的控制，這會很有用。
labels (torch.LongTensor of shape (batch_size,), optional) — 用於計算序列分類/迴歸損失的標籤。索引應在 [0, ..., config.num_labels - 1] 範圍內。如果 config.num_labels == 1，則計算迴歸損失（均方損失）；如果 config.num_labels > 1，則計算分類損失（交叉熵損失）。
output_attentions (bool, optional) — 是否返回所有注意力層的注意力張量。有關詳細資訊，請參閱返回張量中的 attentions。
output_hidden_states (bool, optional) — 是否返回所有層的隱藏狀態。有關詳細資訊，請參閱返回張量中的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通的元組。

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

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

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

LayoutLMForSequenceClassification 的 forward 方法覆蓋了 __call__ 特殊方法。

示例

>>> from transformers import AutoTokenizer, LayoutLMForSequenceClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])
>>> sequence_label = torch.tensor([1])

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=sequence_label,
... )

>>> loss = outputs.loss
>>> logits = outputs.logits

LayoutLMForTokenClassification

class transformers.LayoutLMForTokenClassification

< source >

( config )

引數

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

帶有令牌分類頭（隱藏狀態輸出頂部的線性層）的 LayoutLM 模型，例如用於序列標記（資訊提取）任務，例如 FUNSD 資料集和 SROIE 資料集。

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

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

forward

< source >

( input_ids: typing.Optional[torch.LongTensor] = None bbox: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = 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), optional) — 輸入序列標記在詞彙表中的索引。預設情況下，填充將被忽略。

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

什麼是 input IDs？
bbox (torch.LongTensor of shape (batch_size, sequence_length, 4), optional) — 每個輸入序列標記的邊界框。選擇範圍為 [0, config.max_2d_position_embeddings-1]。每個邊界框都應是 (x0, y0, x1, y1) 格式的歸一化版本，其中 (x0, y0) 對應於邊界框左上角的位置，(x1, y1) 表示右下角的位置。有關歸一化，請參閱概述。
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為 [0, 1]：
- 1 表示**未被掩碼**的標記，
- 0 表示**被掩碼**的標記。
什麼是注意力掩碼？
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 片段標記索引，用於指示輸入的第一個和第二個部分。索引選擇範圍為 [0, 1]：
- 0 對應於**句子 A** 標記，
- 1 對應於**句子 B** 標記。
什麼是標記型別 ID？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每個輸入序列標記在位置嵌入中的位置索引。選擇範圍為 [0, config.n_positions - 1]。

什麼是位置 ID？
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇範圍為 [0, 1]：
- 1 表示頭部**未被掩碼**，
- 0 表示頭部**被掩碼**。
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可選地，除了傳遞 input_ids 之外，您還可以選擇直接傳遞嵌入表示。如果您希望對 input_ids 索引如何轉換為關聯向量擁有比模型內部嵌入查詢矩陣更多的控制，這會很有用。
labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用於計算標記分類損失的標籤。索引應在 [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），包含根據配置（LayoutLMConfig）和輸入的不同元素。

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

LayoutLMForTokenClassification的前向方法，覆蓋了__call__特殊方法。

示例

>>> from transformers import AutoTokenizer, LayoutLMForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = LayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = torch.tensor([token_boxes])
>>> token_labels = torch.tensor([1, 1, 0, 0]).unsqueeze(0)  # batch size of 1

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=token_labels,
... )

>>> loss = outputs.loss
>>> logits = outputs.logits

LayoutLMForQuestionAnswering

class transformers.LayoutLMForQuestionAnswering

< source >

( config has_visual_segment_embedding = True )

引數

config (LayoutLMForQuestionAnswering) — 包含模型所有引數的模型配置類。使用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視from_pretrained()方法來載入模型權重。
has_visual_segment_embedding (bool, 可選, 預設為True) — 是否新增視覺分段嵌入。

Layoutlm transformer，頂部帶有一個跨度分類頭，用於像SQuAD這樣的抽取式問答任務（在隱藏狀態輸出之上有一個線性層來計算`span start logits`和`span end logits`）。

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

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

forward

< source >

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

引數

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

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

什麼是input IDs？
bbox (torch.LongTensor，形狀為(batch_size, sequence_length, 4)，可選) — 每個輸入序列標記的邊界框。選擇範圍為[0, config.max_2d_position_embeddings-1]。每個邊界框應為(x0, y0, x1, y1)格式的歸一化版本，其中(x0, y0)對應於邊界框左上角的位置，(x1, y1)表示右下角的位置。有關歸一化，請參閱概述。
attention_mask (torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 避免對填充標記索引執行注意力的掩碼。掩碼值選擇範圍為[0, 1]：
- 1表示未被掩蓋的標記，
- 0表示被掩蓋的標記。
什麼是注意力掩碼？
token_type_ids (torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 段標記索引，用於指示輸入的第一個和第二個部分。索引選擇範圍為[0, 1]：
- 0對應於句子A標記，
- 1對應於句子B標記。
什麼是token type IDs？
position_ids (torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 輸入序列中每個標記在位置嵌入中的位置索引。選擇範圍為[0, config.n_positions - 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索引轉換為相關向量有更多的控制，而不是模型內部的嵌入查詢矩陣，這將很有用。
start_positions (torch.LongTensor，形狀為(batch_size,)，可選) — 用於計算標記分類損失的標註跨度起始位置（索引）的標籤。位置被限制在序列的長度（sequence_length）範圍內。序列以外的位置不用於計算損失。
end_positions (torch.LongTensor，形狀為(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），包含根據配置（LayoutLMConfig）和輸入的不同元素。

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

LayoutLMForQuestionAnswering的前向方法，覆蓋了__call__特殊方法。

示例

在以下示例中，我們為LayoutLM模型準備了一個問題+上下文對。它將預測它認為答案是什麼（影像中解析文字中的答案範圍）。

>>> from transformers import AutoTokenizer, LayoutLMForQuestionAnswering
>>> from datasets import load_dataset
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("impira/layoutlm-document-qa", add_prefix_space=True)
>>> model = LayoutLMForQuestionAnswering.from_pretrained("impira/layoutlm-document-qa", revision="1e3ebac")

>>> dataset = load_dataset("nielsr/funsd", split="train")
>>> example = dataset[0]
>>> question = "what's his name?"
>>> words = example["words"]
>>> boxes = example["bboxes"]

>>> encoding = tokenizer(
...     question.split(), words, is_split_into_words=True, return_token_type_ids=True, return_tensors="pt"
... )
>>> bbox = []
>>> for i, s, w in zip(encoding.input_ids[0], encoding.sequence_ids(0), encoding.word_ids(0)):
...     if s == 1:
...         bbox.append(boxes[w])
...     elif i == tokenizer.sep_token_id:
...         bbox.append([1000] * 4)
...     else:
...         bbox.append([0] * 4)
>>> encoding["bbox"] = torch.tensor([bbox])

>>> word_ids = encoding.word_ids(0)
>>> outputs = model(**encoding)
>>> loss = outputs.loss
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits
>>> start, end = word_ids[start_scores.argmax(-1)], word_ids[end_scores.argmax(-1)]
>>> print(" ".join(words[start : end + 1]))
M. Hamann P. Harper, P. Martinez

TensorFlow

隱藏 TensorFlow 內容

TFLayoutLMModel

class transformers.TFLayoutLMModel

< source >

( config: LayoutLMConfig *inputs **kwargs )

引數

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

裸LayoutLM模型Transformer，輸出原始隱藏狀態，頂部沒有任何特定頭部。

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

此模型也是keras.Model的子類。將其作為常規的TF 2.0 Keras模型使用，並參考TF 2.0文件以瞭解與一般使用和行為相關的所有事項。

transformers 中的 TensorFlow 模型和層接受兩種輸入格式

所有輸入作為關鍵字引數（如 PyTorch 模型），或
所有輸入作為第一個位置引數中的列表、元組或字典。

支援第二種格式的原因是，Keras 方法在將輸入傳遞給模型和層時更喜歡這種格式。由於這種支援，當使用 `model.fit()` 等方法時，一切都應該“正常工作”——只需以 `model.fit()` 支援的任何格式傳遞你的輸入和標籤即可！但是，如果你想在 `fit()` 和 `predict()` 等 Keras 方法之外使用第二種格式，例如在使用 Keras `Functional` API 建立自己的層或模型時，你可以使用三種可能性來收集所有輸入張量在第一個位置引數中

只有一個 input_ids 的單個張量，沒有其他：model(input_ids)
長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

請注意，當使用子類化建立模型和層時，你無需擔心這些，因為你可以像將輸入傳遞給任何其他Python函式一樣直接傳遞輸入！

呼叫

< source >

引數

input_ids (Numpy陣列或tf.Tensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。

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

什麼是input IDs？
bbox (Numpy陣列或tf.Tensor，形狀為(batch_size, sequence_length, 4)，可選) — 每個輸入序列標記的邊界框。選擇範圍為[0, config.max_2d_position_embeddings-1]。
attention_mask (Numpy陣列或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 避免對填充標記索引執行注意力的掩碼。掩碼值選擇範圍為[0, 1]：
- 1表示未被掩蓋的標記，
- 0表示被掩蓋的標記。
什麼是注意力掩碼？
token_type_ids (Numpy陣列或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 段標記索引，用於指示輸入的第一個和第二個部分。索引選擇範圍為[0, 1]：
- 0對應於句子A標記，
- 1對應於句子B標記。
什麼是token type IDs？
position_ids (Numpy陣列或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 輸入序列中每個標記在位置嵌入中的位置索引。選擇範圍為[0, config.max_position_embeddings - 1]。

什麼是位置ID？
head_mask (Numpy陣列或tf.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇範圍為[0, 1]：
- 1表示頭部未被掩蓋，
- 0表示頭部被掩蓋。
inputs_embeds (tf.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你想對如何將input_ids索引轉換為相關向量有更多的控制，而不是模型內部的嵌入查詢矩陣，這將很有用。
output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的`attentions`。
output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量下的`hidden_states`。
return_dict (bool, 可選) — 是否返回ModelOutput而不是普通元組。
training (bool, 可選, 預設為False) — 是否在訓練模式下使用模型（一些模組如dropout模組在訓練和評估之間有不同的行為）。

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions 或 tuple(tf.Tensor)

一個transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions或一個tf.Tensor元組（如果傳入return_dict=False或config.return_dict=False），包含根據配置（LayoutLMConfig）和輸入的不同元素。

last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。
pooler_output (tf.Tensor，形狀為(batch_size, hidden_size)) — 序列第一個標記（分類標記）的最後一層隱藏狀態，經線性層和Tanh啟用函式進一步處理。預訓練期間，線性層權重根據下一句預測（分類）目標進行訓練。

此輸出通常不是輸入語義內容的良好摘要，通常最好對整個輸入序列的隱藏狀態進行平均或池化。
past_key_values (list[tf.Tensor], 可選, 當傳入use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的tf.Tensor列表，每個張量的形狀為(2, batch_size, num_heads, sequence_length, embed_size_per_head))。

包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。
hidden_states (tuple(tf.Tensor)，可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — tf.Tensor元組（一個用於嵌入輸出+一個用於每一層輸出），形狀為(batch_size, sequence_length, hidden_size)。

模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
attentions (tuple(tf.Tensor)，可選，當傳入output_attentions=True或config.output_attentions=True時返回) — tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
cross_attentions (tuple(tf.Tensor)，可選，當傳入output_attentions=True或config.output_attentions=True時返回) — tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。

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

TFLayoutLMModel的前向方法，覆蓋了__call__特殊方法。

示例

>>> from transformers import AutoTokenizer, TFLayoutLMModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = TFLayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="tf")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = tf.convert_to_tensor([token_boxes])

>>> outputs = model(
...     input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids
... )

>>> last_hidden_states = outputs.last_hidden_state

TFLayoutLMForMaskedLM

class transformers.TFLayoutLMForMaskedLM

< source >

( config: LayoutLMConfig *inputs **kwargs )

引數

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

帶有`language modeling`頭部的LayoutLM模型。

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

此模型也是keras.Model的子類。將其作為常規的TF 2.0 Keras模型使用，並參考TF 2.0文件以瞭解與一般使用和行為相關的所有事項。

transformers 中的 TensorFlow 模型和層接受兩種輸入格式

所有輸入作為關鍵字引數（如 PyTorch 模型），或
所有輸入作為第一個位置引數中的列表、元組或字典。

只有一個 input_ids 的單個張量，沒有其他：model(input_ids)
長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

請注意，當使用子類化建立模型和層時，你無需擔心這些，因為你可以像將輸入傳遞給任何其他Python函式一樣直接傳遞輸入！

呼叫

< source >

引數

input_ids (Numpy陣列或tf.Tensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。

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

什麼是input IDs？
bbox (Numpy陣列或tf.Tensor，形狀為(batch_size, sequence_length, 4)，可選) — 每個輸入序列標記的邊界框。選擇範圍為[0, config.max_2d_position_embeddings-1]。
attention_mask (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為 [0, 1]：
- 1 表示標記 **未被掩碼**，
- 0 表示標記 **已被掩碼**。
什麼是注意力掩碼？
token_type_ids (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length)，可選) — 分段標記索引，用於指示輸入的第一部分和第二部分。索引選擇範圍為 [0, 1]：
- 0 對應於 *句子 A* 標記，
- 1 對應於 *句子 B* 標記。
什麼是標記型別 ID？
position_ids (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。選擇範圍為 [0, config.max_position_embeddings - 1]。

什麼是位置 ID？
head_mask (Numpy array 或 tf.Tensor，形狀為 (num_heads,) 或 (num_layers, num_heads)，可選) — 用於使自注意力模組的選定頭無效的掩碼。掩碼值選擇範圍為 [0, 1]：
- 1 表示頭部 **未被掩碼**，
- 0 表示頭部 **已被掩碼**。
inputs_embeds (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳入嵌入表示，而不是傳入 input_ids。如果您希望對 input_ids 索引如何轉換為相關向量擁有比模型內部嵌入查詢矩陣更多的控制權，則此功能非常有用。
output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的 attentions。
output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量下的 hidden_states。
return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通元組。
training (bool, 可選，預設為 False) — 是否在訓練模式下使用模型（某些模組，如 dropout 模組在訓練和評估之間有不同的行為）。
labels (tf.Tensor 或 np.ndarray，形狀為 (batch_size, sequence_length)，可選) — 用於計算掩碼語言模型損失的標籤。索引應在 [-100, 0, ..., config.vocab_size] 範圍內（請參閱 input_ids 文件字串）。索引設定為 -100 的標記將被忽略（掩碼），損失僅針對標籤在 [0, ..., config.vocab_size] 範圍內的標記計算。

transformers.modeling_tf_outputs.TFMaskedLMOutput 或 tuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFMaskedLMOutput 或一個 tf.Tensor 元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），包含根據配置 (LayoutLMConfig) 和輸入的不同元素。

loss (tf.Tensor of shape (n,), 可選, 其中 n 是非掩碼標籤的數量，當提供 labels 時返回) — 掩碼語言模型 (MLM) 損失。
logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數（SoftMax 之前每個詞彙標記的分數）。
hidden_states (tuple(tf.Tensor)，可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — tf.Tensor元組（一個用於嵌入輸出+一個用於每一層輸出），形狀為(batch_size, sequence_length, hidden_size)。

模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
attentions (tuple(tf.Tensor)，可選，當傳入output_attentions=True或config.output_attentions=True時返回) — tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

TFLayoutLMForMaskedLM 的 forward 方法，重寫了 __call__ 特殊方法。

示例

>>> from transformers import AutoTokenizer, TFLayoutLMForMaskedLM
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = TFLayoutLMForMaskedLM.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "[MASK]"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="tf")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = tf.convert_to_tensor([token_boxes])

>>> labels = tokenizer("Hello world", return_tensors="tf")["input_ids"]

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=labels,
... )

>>> loss = outputs.loss

TFLayoutLMForSequenceClassification

class transformers.TFLayoutLMForSequenceClassification

< source 原始碼 >

( config: LayoutLMConfig *inputs **kwargs )

引數

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

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

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

此模型也是keras.Model的子類。將其作為常規的TF 2.0 Keras模型使用，並參考TF 2.0文件以瞭解與一般使用和行為相關的所有事項。

transformers 中的 TensorFlow 模型和層接受兩種輸入格式

所有輸入作為關鍵字引數（如 PyTorch 模型），或
所有輸入作為第一個位置引數中的列表、元組或字典。

只有一個 input_ids 的單個張量，沒有其他：model(input_ids)
長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

請注意，當使用子類化建立模型和層時，你無需擔心這些，因為你可以像將輸入傳遞給任何其他Python函式一樣直接傳遞輸入！

呼叫

< source 原始碼 >

引數

input_ids (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。

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

什麼是輸入 ID？
bbox (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length, 4)，可選) — 每個輸入序列標記的邊界框。選擇範圍為 [0, config.max_2d_position_embeddings- 1]。
attention_mask (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為 [0, 1]：
- 1 表示標記 **未被掩碼**，
- 0 表示標記 **已被掩碼**。
什麼是注意力掩碼？
token_type_ids (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length)，可選) — 分段標記索引，用於指示輸入的第一部分和第二部分。索引選擇範圍為 [0, 1]：
- 0 對應於 *句子 A* 標記，
- 1 對應於 *句子 B* 標記。
什麼是標記型別 ID？
position_ids (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。選擇範圍為 [0, config.max_position_embeddings - 1]。

什麼是位置 ID？
head_mask (Numpy array 或 tf.Tensor，形狀為 (num_heads,) 或 (num_layers, num_heads)，可選) — 用於使自注意力模組的選定頭無效的掩碼。掩碼值選擇範圍為 [0, 1]：
- 1 表示頭部 **未被掩碼**，
- 0 表示頭部 **已被掩碼**。
inputs_embeds (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳入嵌入表示，而不是傳入 input_ids。如果您希望對 input_ids 索引如何轉換為相關向量擁有比模型內部嵌入查詢矩陣更多的控制權，則此功能非常有用。
output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的 attentions。
output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量下的 hidden_states。
return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通元組。
training (bool, 可選，預設為 False) — 是否在訓練模式下使用模型（某些模組，如 dropout 模組在訓練和評估之間有不同的行為）。
labels (tf.Tensor 或 np.ndarray，形狀為 (batch_size,)，可選) — 用於計算序列分類/迴歸損失的標籤。索引應在 [0, ..., config.num_labels - 1] 範圍內。如果 config.num_labels == 1，則計算迴歸損失（均方損失）；如果 config.num_labels > 1，則計算分類損失（交叉熵）。

transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一個 tf.Tensor 元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），包含根據配置 (LayoutLMConfig) 和輸入的不同元素。

loss (tf.Tensor，形狀為 (batch_size, )，可選，當提供 labels 時返回) — 分類損失（如果 config.num_labels==1，則為迴歸損失）。
logits (tf.Tensor，形狀為 (batch_size, config.num_labels)) — 分類（或迴歸，如果 config.num_labels==1）分數（SoftMax 之前）。
hidden_states (tuple(tf.Tensor)，可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — tf.Tensor元組（一個用於嵌入輸出+一個用於每一層輸出），形狀為(batch_size, sequence_length, hidden_size)。

模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
attentions (tuple(tf.Tensor)，可選，當傳入output_attentions=True或config.output_attentions=True時返回) — tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

TFLayoutLMForSequenceClassification 的 forward 方法，重寫了 __call__ 特殊方法。

示例

>>> from transformers import AutoTokenizer, TFLayoutLMForSequenceClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = TFLayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="tf")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = tf.convert_to_tensor([token_boxes])
>>> sequence_label = tf.convert_to_tensor([1])

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=sequence_label,
... )

>>> loss = outputs.loss
>>> logits = outputs.logits

TFLayoutLMForTokenClassification

class transformers.TFLayoutLMForTokenClassification

< source 原始碼 >

( config: LayoutLMConfig *inputs **kwargs )

引數

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

LayoutLM 模型，頂部帶有一個標記分類頭（隱藏狀態輸出頂部的一個線性層），例如用於命名實體識別（NER）任務。

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

此模型也是keras.Model的子類。將其作為常規的TF 2.0 Keras模型使用，並參考TF 2.0文件以瞭解與一般使用和行為相關的所有事項。

transformers 中的 TensorFlow 模型和層接受兩種輸入格式

所有輸入作為關鍵字引數（如 PyTorch 模型），或
所有輸入作為第一個位置引數中的列表、元組或字典。

只有一個 input_ids 的單個張量，沒有其他：model(input_ids)
長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

請注意，當使用子類化建立模型和層時，你無需擔心這些，因為你可以像將輸入傳遞給任何其他Python函式一樣直接傳遞輸入！

呼叫

< source 原始碼 >

引數

input_ids (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。

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

什麼是輸入 ID？
bbox (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length, 4)，可選) — 每個輸入序列標記的邊界框。選擇範圍為 [0, config.max_2d_position_embeddings- 1]。
attention_mask (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力操作的掩碼。掩碼值選擇範圍為 [0, 1]：
- 1 表示標記 **未被掩碼**，
- 0 表示標記 **已被掩碼**。
什麼是注意力掩碼？
token_type_ids (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length)，可選) — 分段標記索引，用於指示輸入的第一部分和第二部分。索引選擇範圍為 [0, 1]：
- 0 對應於 *句子 A* 標記，
- 1 對應於 *句子 B* 標記。
什麼是標記型別 ID？
position_ids (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。選擇範圍為 [0, config.max_position_embeddings - 1]。

什麼是位置 ID？
head_mask (Numpy array 或 tf.Tensor，形狀為 (num_heads,) 或 (num_layers, num_heads)，可選) — 用於使自注意力模組的選定頭無效的掩碼。掩碼值選擇範圍為 [0, 1]：
- 1 表示頭部 **未被掩碼**，
- 0 表示頭部 **已被掩碼**。
inputs_embeds (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳入嵌入表示，而不是傳入 input_ids。如果您希望對 input_ids 索引如何轉換為相關向量擁有比模型內部嵌入查詢矩陣更多的控制權，則此功能非常有用。
output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的 attentions。
output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量下的 hidden_states。
return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通元組。
training (bool, 可選，預設為 False) — 是否在訓練模式下使用模型（某些模組，如 dropout 模組在訓練和評估之間有不同的行為）。
labels (tf.Tensor 或 np.ndarray，形狀為 (batch_size, sequence_length)，可選) — 用於計算標記分類損失的標籤。索引應在 [0, ..., config.num_labels - 1] 範圍內。

transformers.modeling_tf_outputs.TFTokenClassifierOutput 或 tuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFTokenClassifierOutput 或一個 tf.Tensor 元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），包含根據配置 (LayoutLMConfig) 和輸入的不同元素。

loss (tf.Tensor，形狀為 (n,)，可選，其中 n 是未被掩蓋的標籤數量，當提供 labels 時返回) — 分類損失。
logits (tf.Tensor，形狀為 (batch_size, sequence_length, config.num_labels)) — 分類分數（SoftMax 之前）。
hidden_states (tuple(tf.Tensor)，可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — tf.Tensor元組（一個用於嵌入輸出+一個用於每一層輸出），形狀為(batch_size, sequence_length, hidden_size)。

模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
attentions (tuple(tf.Tensor)，可選，當傳入output_attentions=True或config.output_attentions=True時返回) — tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

TFLayoutLMForTokenClassification 的 forward 方法，重寫了 __call__ 特殊方法。

示例

>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFLayoutLMForTokenClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
>>> model = TFLayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased")

>>> words = ["Hello", "world"]
>>> normalized_word_boxes = [637, 773, 693, 782], [698, 773, 733, 782]

>>> token_boxes = []
>>> for word, box in zip(words, normalized_word_boxes):
...     word_tokens = tokenizer.tokenize(word)
...     token_boxes.extend([box] * len(word_tokens))
>>> # add bounding boxes of cls + sep tokens
>>> token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]

>>> encoding = tokenizer(" ".join(words), return_tensors="tf")
>>> input_ids = encoding["input_ids"]
>>> attention_mask = encoding["attention_mask"]
>>> token_type_ids = encoding["token_type_ids"]
>>> bbox = tf.convert_to_tensor([token_boxes])
>>> token_labels = tf.convert_to_tensor([1, 1, 0, 0])

>>> outputs = model(
...     input_ids=input_ids,
...     bbox=bbox,
...     attention_mask=attention_mask,
...     token_type_ids=token_type_ids,
...     labels=token_labels,
... )

>>> loss = outputs.loss
>>> logits = outputs.logits

TFLayoutLMForQuestionAnswering

class transformers.TFLayoutLMForQuestionAnswering

< source 原始碼 >

( config: LayoutLMConfig *inputs **kwargs )

引數

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

LayoutLM 模型，頂部帶有一個用於抽取式問答任務（如 DocVQA）的跨度分類頭（最終隱藏狀態輸出頂部的一個線性層，用於計算 span start logits 和 span end logits）。

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

此模型也是keras.Model的子類。將其作為常規的TF 2.0 Keras模型使用，並參考TF 2.0文件以瞭解與一般使用和行為相關的所有事項。

transformers 中的 TensorFlow 模型和層接受兩種輸入格式

所有輸入作為關鍵字引數（如 PyTorch 模型），或
所有輸入作為第一個位置引數中的列表、元組或字典。

只有一個 input_ids 的單個張量，沒有其他：model(input_ids)
長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

請注意，當使用子類化建立模型和層時，你無需擔心這些，因為你可以像將輸入傳遞給任何其他Python函式一樣直接傳遞輸入！

呼叫

< source 原始碼 >

引數

input_ids (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length)) — 詞彙表中輸入序列 token 的索引。

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

什麼是輸入 ID？
bbox (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length, 4), 可選) — 每個輸入序列 token 的邊界框。選擇範圍為 [0, config.max_2d_position_embeddings- 1]。
attention_mask (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length), 可選) — 掩碼，用於避免對填充 token 索引執行注意力操作。掩碼值選擇範圍為 [0, 1]：
- 1 表示 token 未被掩蓋，
- 0 表示 token 被掩蓋。
什麼是注意力掩碼？
token_type_ids (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length), 可選) — 分段 token 索引，用於指示輸入的第一個和第二個部分。索引選擇範圍為 [0, 1]：
- 0 對應於 句子 A token，
- 1 對應於 句子 B token。
什麼是 token 型別 ID？
position_ids (Numpy array 或 tf.Tensor，形狀為 (batch_size, sequence_length), 可選) — 每個輸入序列 token 在位置嵌入中的位置索引。選擇範圍為 [0, config.max_position_embeddings - 1]。

什麼是位置 ID？
head_mask (Numpy array 或 tf.Tensor，形狀為 (num_heads,) 或 (num_layers, num_heads), 可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選擇範圍為 [0, 1]：
- 1 表示頭部未被掩蓋，
- 0 表示頭部被掩蓋。
inputs_embeds (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size), 可選) — 可選地，您可以直接傳遞嵌入表示而不是傳遞 input_ids。如果您希望對 input_ids 索引如何轉換為相關向量有更多控制，而不是模型內部的嵌入查詢矩陣，這將非常有用。
output_attentions (bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳情請參見返回張量下的 attentions。
output_hidden_states (bool, 可選) — 是否返回所有層的隱藏狀態。更多詳情請參見返回張量下的 hidden_states。
return_dict (bool, 可選) — 是否返回 ModelOutput 而不是普通的元組。
training (bool, 可選, 預設為 False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估之間有不同的行為）。
start_positions (tf.Tensor 或 np.ndarray，形狀為 (batch_size,), 可選) — 用於計算 token 分類損失的標註跨度起始位置（索引）的標籤。位置被限制在序列長度（sequence_length）內。序列外的位置不計入損失計算。
end_positions (tf.Tensor 或 np.ndarray，形狀為 (batch_size,), 可選) — 用於計算 token 分類損失的標註跨度結束位置（索引）的標籤。位置被限制在序列長度（sequence_length）內。序列外的位置不計入損失計算。

transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或 tuple(tf.Tensor)

一個 transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或一個 tf.Tensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置 (LayoutLMConfig) 和輸入而變化的各種元素。

loss (tf.Tensor，形狀為 (batch_size, ), 可選, 當提供了 start_positions 和 end_positions 時返回) — 總跨度提取損失是起始位置和結束位置的交叉熵之和。
start_logits (形狀為 (batch_size, sequence_length) 的 tf.Tensor) — 跨度起始分數（SoftMax 之前）。
end_logits (形狀為 (batch_size, sequence_length) 的 tf.Tensor) — 跨度結束分數（SoftMax 之前）。
hidden_states (tuple(tf.Tensor)，可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — tf.Tensor元組（一個用於嵌入輸出+一個用於每一層輸出），形狀為(batch_size, sequence_length, hidden_size)。

模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
attentions (tuple(tf.Tensor)，可選，當傳入output_attentions=True或config.output_attentions=True時返回) — tf.Tensor元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

TFLayoutLMForQuestionAnswering 的 forward 方法重寫了 __call__ 特殊方法。

示例

>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFLayoutLMForQuestionAnswering
>>> from datasets import load_dataset

>>> tokenizer = AutoTokenizer.from_pretrained("impira/layoutlm-document-qa", add_prefix_space=True)
>>> model = TFLayoutLMForQuestionAnswering.from_pretrained("impira/layoutlm-document-qa", revision="1e3ebac")

>>> dataset = load_dataset("nielsr/funsd", split="train")
>>> example = dataset[0]
>>> question = "what's his name?"
>>> words = example["words"]
>>> boxes = example["bboxes"]

>>> encoding = tokenizer(
...     question.split(), words, is_split_into_words=True, return_token_type_ids=True, return_tensors="tf"
... )
>>> bbox = []
>>> for i, s, w in zip(encoding.input_ids[0], encoding.sequence_ids(0), encoding.word_ids(0)):
...     if s == 1:
...         bbox.append(boxes[w])
...     elif i == tokenizer.sep_token_id:
...         bbox.append([1000] * 4)
...     else:
...         bbox.append([0] * 4)
>>> encoding["bbox"] = tf.convert_to_tensor([bbox])

>>> word_ids = encoding.word_ids(0)
>>> outputs = model(**encoding)
>>> loss = outputs.loss
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits
>>> start, end = word_ids[tf.math.argmax(start_scores, -1)[0]], word_ids[tf.math.argmax(end_scores, -1)[0]]
>>> print(" ".join(words[start : end + 1]))
M. Hamann P. Harper, P. Martinez

< > 在 GitHub 上更新

Transformers

LayoutLM

概述

使用技巧

資源

LayoutLMConfig

class transformers.LayoutLMConfig

LayoutLMTokenizer

class transformers.LayoutLMTokenizer

build_inputs_with_special_tokens

convert_tokens_to_string

get_special_tokens_mask

LayoutLMTokenizerFast

class transformers.LayoutLMTokenizerFast

build_inputs_with_special_tokens

LayoutLMModel

class transformers.LayoutLMModel

forward

LayoutLMForMaskedLM

class transformers.LayoutLMForMaskedLM

forward

LayoutLMForSequenceClassification

class transformers.LayoutLMForSequenceClassification

forward

LayoutLMForTokenClassification

class transformers.LayoutLMForTokenClassification

forward

LayoutLMForQuestionAnswering

class transformers.LayoutLMForQuestionAnswering

forward

TFLayoutLMModel

class transformers.TFLayoutLMModel

呼叫

TFLayoutLMForMaskedLM

class transformers.TFLayoutLMForMaskedLM

呼叫

TFLayoutLMForSequenceClassification

class transformers.TFLayoutLMForSequenceClassification

呼叫

TFLayoutLMForTokenClassification

class transformers.TFLayoutLMForTokenClassification

呼叫

TFLayoutLMForQuestionAnswering

class transformers.TFLayoutLMForQuestionAnswering

呼叫