Transformers 文件
UDOP
並獲得增強的文件體驗
開始使用
UDOP
概述
UDOP 模型由 Zineng Tang、Ziyi Yang、Guoxin Wang、Yuwei Fang、Yang Liu、Chenguang Zhu、Michael Zeng、Cha Zhang 和 Mohit Bansal 在論文 Unifying Vision, Text, and Layout for Universal Document Processing 中提出。UDOP 採用基於 T5 的編碼器-解碼器 Transformer 架構,用於處理文件 AI 任務,如文件影像分類、文件解析和文件視覺問答。
論文摘要如下:
我們提出了通用文件處理(UDOP),這是一個基礎的文件 AI 模型,它將文字、影像和佈局模態與各種任務格式(包括文件理解和生成)統一起來。UDOP 利用文字內容和文件影像之間的空間相關性,用一種統一的表示來建模影像、文字和佈局模態。透過一個新穎的視覺-文字-佈局 Transformer,UDOP 將預訓練和多領域下游任務統一為一個基於提示的序列生成方案。UDOP 在大規模未標記文件語料庫上使用創新的自監督目標進行預訓練,並利用多樣化的標記資料進行訓練。UDOP 還透過掩碼影像重建學習從文字和佈局模態生成文件影像。據我們所知,這是文件 AI 領域首次有一個模型同時實現了高質量的神經文件編輯和內容定製。我們的方法在 9 個文件 AI 任務上達到了業界領先水平,例如,在金融報告、學術論文和網站等不同資料領域的文件理解和問答任務上。UDOP 在文件理解基準(DUE)排行榜上排名第一。*

使用技巧
- 除了 input_ids,UdopForConditionalGeneration 還需要輸入
bbox
,即輸入詞元的邊界框(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
對應於詞元所在原始文件的寬度和高度。這些可以使用 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
可以使用 UdopProcessor 為模型準備影像和文字,它會處理所有這些工作。預設情況下,此類使用 Tesseract 引擎從給定文件中提取單詞列表和邊界框(座標)。其功能與 LayoutLMv3Processor 相當,因此支援傳遞 apply_ocr=False
(如果你傾向於使用自己的 OCR 引擎)或 apply_ocr=True
(如果你想使用預設的 OCR 引擎)。關於所有可能的用例,請參考 LayoutLMv2 的使用指南(UdopProcessor
的功能是相同的)。
- 如果使用自己選擇的 OCR 引擎,推薦使用 Azure 的 Read API,它支援所謂的行段。使用段落位置嵌入通常會帶來更好的效能。
- 在推理時,建議使用
generate
方法,根據文件影像自迴歸地生成文字。 - 該模型已在自監督和有監督目標上進行了預訓練。可以使用預訓練期間使用的各種任務字首(提示)來測試其開箱即用的能力。例如,可以使用 “Question answering. What is the date?” 來提示模型,因為 “Question answering.” 是預訓練期間用於 DocVQA 的任務字首。有關所有任務字首,請參閱論文(表 1)。
- 也可以微調 UdopEncoderModel,它是 UDOP 的僅編碼器部分,可以看作是一個類似 LayoutLMv3 的 Transformer 編碼器。對於判別性任務,可以在其之上新增一個線性分類器,並在標記資料集上進行微調。
資源
以下是 Hugging Face 官方和社群(由 🌎 標誌指示)提供的資源列表,幫助您開始使用 UDOP。如果您有興趣提交資源以包含在此處,請隨時發起 Pull Request,我們將進行稽核!該資源最好能展示一些新內容,而不是重複現有資源。
UdopConfig
class transformers.UdopConfig
< 源 >( vocab_size = 33201 d_model = 1024 d_kv = 64 d_ff = 4096 num_layers = 24 num_decoder_layers = None num_heads = 16 relative_attention_num_buckets = 32 relative_attention_max_distance = 128 relative_bias_args = [{'type': '1d'}, {'type': 'horizontal'}, {'type': 'vertical'}] dropout_rate = 0.1 layer_norm_epsilon = 1e-06 initializer_factor = 1.0 feed_forward_proj = 'relu' is_encoder_decoder = True use_cache = True pad_token_id = 0 eos_token_id = 1 max_2d_position_embeddings = 1024 image_size = 224 patch_size = 16 num_channels = 3 **kwargs )
引數
- vocab_size (
int
, 可選, 預設為 33201) — UDOP 模型的詞彙表大小。定義了在呼叫 UdopForConditionalGeneration 時傳遞的inputs_ids
可以表示的不同詞元的數量。 - d_model (
int
, 可選, 預設為 1024) — 編碼器層和池化層的大小。 - d_kv (
int
, 可選, 預設為 64) — 每個注意力頭的鍵、查詢、值投影的大小。投影層的inner_dim
將定義為num_heads * d_kv
。 - d_ff (
int
, 可選, 預設為 4096) — 每個UdopBlock
中中間前饋層的大小。 - num_layers (
int
, 可選, 預設為 24) — Transformer 編碼器和解碼器中的隱藏層數量。 - num_decoder_layers (
int
, 可選) — Transformer 解碼器中的隱藏層數量。如果未設定,將使用與num_layers
相同的值。 - num_heads (
int
, 可選, 預設為 16) — Transformer 編碼器和解碼器中每個注意力層的注意力頭數量。 - relative_attention_num_buckets (
int
, 可選, 預設為 32) — 每個注意力層使用的桶的數量。 - relative_attention_max_distance (
int
, 可選, 預設為 128) — 用於桶分離的較長序列的最大距離。 - relative_bias_args (
list[dict]
, 可選, 預設為[{'type' -- '1d'}, {'type': 'horizontal'}, {'type': 'vertical'}]
): 一個包含相對偏置層引數的字典列表。 - dropout_rate (
float
, 可選, 預設為 0.1) — 所有 dropout 層的比率。 - layer_norm_epsilon (
float
, 可選, 預設為 1e-06) — 層歸一化層使用的 epsilon 值。 - initializer_factor (
float
, 可選, 預設為 1.0) — 用於初始化所有權重矩陣的因子(應保持為 1,內部用於初始化測試)。 - feed_forward_proj (
string
, 可選, 預設為"relu"
) — 要使用的前饋層的型別。應為"relu"
或"gated-gelu"
之一。Udopv1.1 使用"gated-gelu"
前饋投影。原始 Udop 使用"relu"
。 - is_encoder_decoder (
bool
, 可選, 預設為True
) — 模型是否應作為編碼器/解碼器執行。 - use_cache (
bool
, 可選, 預設為True
) — 模型是否應返回最後一個鍵/值注意力(並非所有模型都使用)。 - pad_token_id (
int
, 可選, 預設為 0) — 詞彙表中填充詞元的 ID。 - eos_token_id (
int
, 可選, 預設為 1) — 詞彙表中序列結束詞元的 ID。 - max_2d_position_embeddings (
int
, 可選, 預設為 1024) — 相對位置編碼的最大絕對位置嵌入。 - image_size (
int
, 可選, 預設為 224) — 輸入影像的大小。 - patch_size (
int
, 可選, 預設為 16) — 視覺編碼器使用的影像塊大小。 - num_channels (
int
, 可選, 預設為 3) — 輸入影像的通道數。
這是用於儲存 UdopForConditionalGeneration 配置的配置類。它用於根據指定的引數例項化一個 UDOP 模型,定義模型架構。使用預設值例項化配置將產生與 UDOP microsoft/udop-large 架構類似的配置。
配置物件繼承自 PretrainedConfig,可用於控制模型輸出。有關更多資訊,請閱讀 PretrainedConfig 的文件。
UdopTokenizer
class transformers.UdopTokenizer
< 源 >( vocab_file eos_token = '</s>' unk_token = '<unk>' sep_token = '</s>' pad_token = '<pad>' sep_token_box = [1000, 1000, 1000, 1000] pad_token_box = [0, 0, 0, 0] pad_token_label = -100 only_label_first_subword = True additional_special_tokens = None sp_model_kwargs: typing.Optional[dict[str, typing.Any]] = None legacy = True add_prefix_space = True **kwargs )
引數
- vocab_file (
str
) — 詞彙表文件的路徑。 - eos_token (
str
, 可選, 預設為"</s>"
) — 序列結束詞元。在使用特殊詞元構建序列時,這不是用於序列結束的詞元。使用的詞元是 `sep_token`。
- unk_token (
str
, 可選, 預設為"<unk>"
) — 未知詞元。不在詞彙表中的詞元無法轉換為 ID,將被設定為此詞元。 - sep_token (
str
, 可選, 預設為"</s>"
) — 分隔符詞元,用於從多個序列構建一個序列時,例如,序列分類的兩個序列,或問答任務中的文字和問題。它也用作使用特殊詞元構建的序列的最後一個詞元。 - pad_token (
str
, 可選, 預設為"<pad>"
) — 用於填充的詞元,例如在批處理不同長度的序列時使用。 - sep_token_box (
list[int]
, 可選, 預設為[1000, 1000, 1000, 1000]
) — 用於特殊 [SEP] 詞元的邊界框。 - pad_token_box (
list[int]
, 可選, 預設為[0, 0, 0, 0]
) — 用於特殊 [PAD] 詞元的邊界框。 - pad_token_label (
int
, 可選, 預設為 -100) — 用於填充詞元的標籤。預設為 -100,這是 PyTorch 的 CrossEntropyLoss 的 `ignore_index`。 - only_label_first_subword (
bool
, 可選, 預設為True
) — 是否僅標記第一個子詞,在提供單詞標籤的情況下。 - additional_special_tokens (
list[str]
, 可選, 預設為["<s>NOTUSED", "</s>NOTUSED"]
) — 分詞器使用的額外特殊詞元。 - sp_model_kwargs (
dict
, 可選) — 將傳遞給SentencePieceProcessor.__init__()
方法。SentencePiece 的 Python 包裝器可用於設定以下內容等:-
enable_sampling
:啟用子詞正則化。 -
nbest_size
:unigram 的取樣引數。對 BPE-Dropout 無效。nbest_size = {0,1}
:不執行取樣。nbest_size > 1
:從 nbest_size 個結果中取樣。nbest_size < 0
:假設 nbest_size 是無限的,並使用前向過濾和後向取樣演算法從所有假設(格)中取樣。
-
alpha
:unigram 取樣的平滑引數,以及 BPE-dropout 的合併操作的 dropout 機率。
-
- legacy (
bool
, 可選,預設為True
) — 是否使用分詞器的legacy
行為。Legacy 指的是在合併 #24622 之前的行為,該合併修復了正確處理特殊詞元(special token)之後出現的詞元的問題。一個簡單的例子:legacy=True
:
改編自 LayoutXLMTokenizer 和 T5Tokenizer。基於 SentencePiece。
此分詞器繼承自 PreTrainedTokenizer,其中包含了大部分主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。
build_inputs_with_special_tokens
< 原始碼 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
透過連線和新增特殊標記,從序列或序列對構建用於序列分類任務的模型輸入。序列格式如下:
- 單個序列:
X </s>
- 序列對:
A </s> B </s>
get_special_tokens_mask
< 原始碼 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → list[int]
從沒有新增特殊標記的標記列表中檢索序列ID。此方法在使用分詞器prepare_for_model
方法新增特殊標記時呼叫。
create_token_type_ids_from_sequences
< 原始碼 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
根據傳入的兩個序列建立掩碼,用於序列對分類任務。T5 不使用令牌型別 ID,因此返回零列表。
UdopTokenizerFast
class transformers.UdopTokenizerFast
< 原始碼 >( vocab_file = None tokenizer_file = None eos_token = '</s>' sep_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' sep_token_box = [1000, 1000, 1000, 1000] pad_token_box = [0, 0, 0, 0] pad_token_label = -100 only_label_first_subword = True additional_special_tokens = None **kwargs )
引數
- vocab_file (
str
, 可選) — 詞彙表文件的路徑。 - tokenizer_file (
str
, 可選) — 分詞器檔案的路徑。 - eos_token (
str
, 可選,預設為"</s>"
) — 序列結束詞元。當使用特殊詞元構建序列時,這不是用於序列結束的詞元。使用的詞元是 `sep_token`。
- sep_token (
str
, 可選,預設為"</s>"
) — 分隔符詞元,用於從多個序列構建一個序列,例如用於序列分類的兩個序列,或用於問答的文字和問題。它也用作使用特殊詞元構建的序列的最後一個詞元。 - unk_token (
str
, 可選,預設為"<unk>"
) — 未知詞元。不在詞彙表中的詞元無法轉換為 ID,將被設定為此詞元。 - pad_token (
str
, 可選,預設為"<pad>"
) — 用於填充的詞元,例如在批處理不同長度的序列時使用。 - sep_token_box (
list[int]
, 可選,預設為[1000, 1000, 1000, 1000]
) — 用於特殊 [SEP] 詞元的邊界框。 - pad_token_box (
list[int]
, 可選,預設為[0, 0, 0, 0]
) — 用於特殊 [PAD] 詞元的邊界框。 - pad_token_label (
int
, 可選,預設為 -100) — 用於填充詞元的標籤。預設為 -100,這是 PyTorch 的 CrossEntropyLoss 的 `ignore_index`。 - only_label_first_subword (
bool
, 可選,預設為True
) — 如果提供了單詞標籤,是否只標記第一個子詞。 - additional_special_tokens (
list[str]
, 可選,預設為["<s>NOTUSED", "</s>NOTUSED"]
) — 分詞器使用的額外特殊詞元。
構建一個“快速”的 UDOP 分詞器(由 HuggingFace 的 *tokenizers* 庫支援)。改編自 LayoutXLMTokenizer 和 T5Tokenizer。基於 BPE。
此分詞器繼承自 PreTrainedTokenizerFast,其中包含了大部分主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。
batch_encode_plus_boxes
< 原始碼 >( batch_text_or_text_pairs: typing.Union[list[str], list[tuple[str, str]], list[list[str]]] is_pair: typing.Optional[bool] = None boxes: typing.Optional[list[list[list[int]]]] = None word_labels: typing.Optional[list[list[int]]] = 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 is_split_into_words: bool = False pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = 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 **kwargs )
對一個序列列表或序列對列表進行分詞併為模型做準備。
此方法已棄用,應改用 `__call__`。
build_inputs_with_special_tokens
< 原始碼 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
透過連線和新增特殊 token,為序列分類任務從序列或序列對構建模型輸入。XLM-RoBERTa 序列的格式如下:
- 單個序列:
<s> X </s>
- 序列對:
<s> A </s></s> B </s>
call_boxes
< 原始碼 >( text: typing.Union[str, list[str], list[list[str]]] text_pair: typing.Union[list[str], list[list[str]], NoneType] = None boxes: typing.Union[list[list[int]], list[list[list[int]]], NoneType] = None word_labels: typing.Union[list[int], list[list[int]], NoneType] = 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 padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = 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 **kwargs ) → BatchEncoding
引數
- text (
str
,list[str]
,list[list[str]]
) — 待編碼的序列或序列批次。每個序列可以是一個字串、一個字串列表(單個示例的單詞或一批示例的問題)或一個字串列表的列表(一批單詞)。 - text_pair (
list[str]
,list[list[str]]
) — 待編碼的序列或序列批次。每個序列應為一個字串列表(預分詞的字串)。 - boxes (
list[list[int]]
,list[list[list[int]]]
) — 詞級邊界框。每個邊界框都應歸一化到 0-1000 的範圍。 - word_labels (
list[int]
,list[list[int]]
, 可選) — 詞級整數標籤(用於如 FUNSD、CORD 等詞元分類任務)。 - add_special_tokens (
bool
, 可選,預設為True
) — 是否使用與模型相關的特殊詞元對序列進行編碼。 - padding (
bool
,str
或 PaddingStrategy, 可選,預設為False
) — 啟用並控制填充。接受以下值:True
或'longest'
: 填充到批次中最長的序列(如果只提供單個序列則不填充)。'max_length'
: 填充到由 `max_length` 引數指定的最大長度,如果未提供該引數,則填充到模型的最大可接受輸入長度。False
或'do_not_pad'
(預設): 不填充(即可以輸出具有不同長度序列的批次)。
- truncation (
bool
,str
或 TruncationStrategy, 可選,預設為False
) — 啟用並控制截斷。接受以下值:True
或'longest_first'
: 截斷到由 `max_length` 引數指定的最大長度,如果未提供該引數,則截斷到模型的最大可接受輸入長度。如果提供了一對序列(或一批序列對),這將逐個詞元地截斷,從最長的序列中移除一個詞元。'only_first'
: 截斷到由 `max_length` 引數指定的最大長度,如果未提供該引數,則截斷到模型的最大可接受輸入長度。如果提供了一對序列(或一批序列對),這隻會截斷第一個序列。'only_second'
: 截斷到由 `max_length` 引數指定的最大長度,如果未提供該引數,則截斷到模型的最大可接受輸入長度。如果提供了一對序列(或一批序列對),這隻會截斷第二個序列。False
或'do_not_truncate'
(預設): 不截斷(即可以輸出序列長度大於模型最大可接受輸入尺寸的批次)。
- max_length (
int
, 可選) — 控制截斷/填充引數使用的最大長度。如果未設定或設定為
None
,當截斷/填充引數需要最大長度時,將使用預定義的模型最大長度。如果模型沒有特定的最大輸入長度(如 XLNet),則停用截斷/填充到最大長度的功能。 - stride (
int
, 可選,預設為 0) — 如果與 `max_length` 一起設定,當 `return_overflowing_tokens=True` 時返回的溢位詞元將包含一些來自返回的截斷序列末尾的詞元,以提供截斷和溢位序列之間的一些重疊。此引數的值定義了重疊詞元的數量。 - pad_to_multiple_of (
int
, 可選) — 如果設定,將序列填充到所提供值的倍數。這對於在計算能力 `>= 7.5` (Volta) 的 NVIDIA 硬體上使用 Tensor Cores 特別有用。 - return_tensors (
str
或 TensorType, 可選) — 如果設定,將返回張量而不是 Python 整數列表。可接受的值為:'tf'
: 返回 TensorFlowtf.constant
物件。'pt'
: 返回 PyTorchtorch.Tensor
物件。'np'
: 返回 Numpynp.ndarray
物件。
- return_token_type_ids (
bool
, 可選) — 是否返回詞元型別 ID。如果保留預設值,將根據特定分詞器的預設設定返回詞元型別 ID,該設定由 `return_outputs` 屬性定義。 - return_attention_mask (
bool
, 可選) — 是否返回注意力掩碼。如果保留預設值,將根據特定分詞器的預設設定返回注意力掩碼,該設定由 `return_outputs` 屬性定義。 - return_overflowing_tokens (
bool
, 可選,預設為False
) — 是否返回溢位的詞元序列。如果提供了一對輸入 ID 序列(或一批序列對)並使用 `truncation_strategy = longest_first` 或 `True`,則會引發錯誤,而不是返回溢位的詞元。 - return_special_tokens_mask (
bool
, 可選,預設為False
) — 是否返回特殊詞元掩碼資訊。 - return_offsets_mapping (
bool
, 可選,預設為False
) — 是否為每個詞元返回 `(char_start, char_end)`。這僅在繼承自 PreTrainedTokenizerFast 的快速分詞器上可用,如果使用 Python 的分詞器,此方法將引發 `NotImplementedError`。
- return_length (
bool
, 可選,預設為False
) — 是否返回編碼輸入的長度。 - verbose (
bool
, 可選,預設為True
) — 是否列印更多資訊和警告。 - **kwargs — 傳遞給 `self.tokenize()` 方法
一個 BatchEncoding,包含以下欄位:
-
input_ids — 要輸入到模型中的標記 ID 列表。
-
bbox — 待輸入模型的邊界框列表。
-
token_type_ids — 要輸入到模型中的標記型別 ID 列表(當
return_token_type_ids=True
或如果 *“token_type_ids”* 在self.model_input_names
中時)。 -
attention_mask — 指定模型應關注哪些標記的索引列表(當
return_attention_mask=True
或如果 *“attention_mask”* 在self.model_input_names
中時)。 -
labels — 待輸入模型的標籤列表。(當指定
word_labels
時)。 -
overflowing_tokens — 溢位標記序列列表(當指定
max_length
且return_overflowing_tokens=True
時)。 -
num_truncated_tokens — 截斷標記的數量(當指定
max_length
且return_overflowing_tokens=True
時)。 -
special_tokens_mask — 0 和 1 的列表,其中 1 表示新增的特殊標記,0 表示常規序列標記(當
add_special_tokens=True
且return_special_tokens_mask=True
時)。 -
length — 輸入的長度(當
return_length=True
時)。
對一個或多個序列或一對序列進行分詞並準備輸入模型的主要方法,其中包含詞級別的歸一化邊界框和可選標籤。
create_token_type_ids_from_sequences
< 原始碼 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
根據傳入的兩個序列建立用於序列對分類任務的掩碼。XLM-RoBERTa 不使用 token 型別 ID,因此返回一個全零列表。
encode_boxes
< source >( text: typing.Union[str, list[str], list[int]] text_pair: typing.Union[str, list[str], list[int], NoneType] = None boxes: typing.Optional[list[list[int]]] = None word_labels: typing.Optional[list[list[int]]] = 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 return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None **kwargs )
引數
- 使用分詞器和詞彙表,將字串 轉換 為ID序列(整數)。與執行以下操作相同 —
-
self.convert_tokens_to_ids(self.tokenize(text))
。 — text (str
,list[str]
或list[int]
): 要編碼的第一個序列。這可以是一個字串、一個字串列表(使用tokenize
方法分詞後的字串)或一個整數列表(使用convert_tokens_to_ids
方法分詞後的字串ID)。text_pair (str
,list[str]
或list[int]
, optional): 可選的要編碼的第二個序列。這可以是一個字串、一個字串列表(使用tokenize
方法分詞後的字串)或一個整數列表(使用convert_tokens_to_ids
方法分詞後的字串ID)。
encode_plus_boxes
< source >( text: typing.Union[str, list[str]] text_pair: typing.Optional[list[str]] = None boxes: typing.Optional[list[list[int]]] = None word_labels: typing.Optional[list[list[int]]] = 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 is_split_into_words: bool = False pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = 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 **kwargs )
引數
- text (
str
,list[str]
or (for non-fast tokenizers)list[int]
) — 要編碼的第一個序列。這可以是一個字串、一個字串列表(使用tokenize
方法分詞後的字串)或一個整數列表(使用convert_tokens_to_ids
方法分詞後的字串ID)。 - text_pair (
str
,list[str]
orlist[int]
, optional) — 可選的要編碼的第二個序列。這可以是一個字串、一個字串列表(使用tokenize
方法分詞後的字串)或一個整數列表(使用convert_tokens_to_ids
方法分詞後的字串ID)。
對一個序列或一對序列進行分詞併為模型做準備。
此方法已棄用,應改用 `__call__`。
UdopProcessor
class transformers.UdopProcessor
< source >( image_processor tokenizer )
引數
- image_processor (
LayoutLMv3ImageProcessor
) — LayoutLMv3ImageProcessor的一個例項。影像處理器是必需的輸入。 - tokenizer (
UdopTokenizer
或UdopTokenizerFast
) — UdopTokenizer 或 UdopTokenizerFast 的一個例項。分詞器是必需的輸入。
構建一個 UDOP 處理器,它將 LayoutLMv3 影像處理器和 UDOP 分詞器組合成一個單一的處理器。
UdopProcessor 提供了為模型準備資料所需的所有功能。
它首先使用 LayoutLMv3ImageProcessor 來調整、縮放和歸一化文件影像,並可選地應用OCR以獲取單詞和歸一化的邊界框。然後將這些提供給 UdopTokenizer 或 UdopTokenizerFast,後者將單詞和邊界框轉換為詞元級別的 `input_ids`、`attention_mask`、`token_type_ids` 和 `bbox`。可選地,可以提供整數 `word_labels`,這些標籤會被轉換為詞元級別的 `labels` 用於詞元分類任務(如FUNSD, CORD)。
此外,它還支援向分詞器傳遞 `text_target` 和 `text_pair_target`,可用於為語言建模任務準備標籤。
__call__
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None text: typing.Union[str, list[str], list[list[str]]] = None *args audio = None videos = None **kwargs: typing_extensions.Unpack[transformers.models.udop.processing_udop.UdopProcessorKwargs] )
此方法首先將 `images` 引數轉發給 `~UdopImageProcessor.__call__`。如果 `UdopImageProcessor` 初始化時 `apply_ocr` 設定為 `True`,它會將獲取的單詞和邊界框連同其他引數一起傳遞給 `__call__()` 並返回輸出,以及準備好的 `pixel_values`。如果 `UdopImageProcessor` 初始化時 `apply_ocr` 設定為 `False`,它會將使用者指定的單詞(`text`/`text_pair`)和 `boxes` 連同其他引數一起傳遞給 `__call__()` 並返回輸出,以及準備好的 `pixel_values`。
另外,也可以傳遞 `text_target` 和 `text_pair_target` 來準備 UDOP 的目標。
有關更多資訊,請參閱上述兩種方法的文件字串。
UdopModel
class transformers.UdopModel
< source >( config )
引數
- config (UdopModel) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重,只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
基礎的 Udop 模型,輸出原始的隱藏狀態,頂部沒有任何特定的頭。
該模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為其所有模型實現的通用方法(例如下載或儲存、調整輸入嵌入大小、修剪頭部等)。
該模型也是 PyTorch torch.nn.Module 的子類。可以像常規 PyTorch 模組一樣使用它,並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None bbox: typing.Optional[dict[str, typing.Any]] = None pixel_values: typing.Optional[torch.Tensor] = None visual_bbox: typing.Optional[dict[str, typing.Any]] = None decoder_input_ids: typing.Optional[torch.Tensor] = None decoder_attention_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_inputs_embeds: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None use_cache = True output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None )
引數
- input_ids (
torch.Tensor
,形狀為(batch_size, sequence_length)
, optional) — 詞彙表中輸入序列詞元的索引。預設情況下,填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor
,形狀為(batch_size, sequence_length)
, optional) — 用於避免對填充詞元索引執行注意力操作的掩碼。掩碼值在[0, 1]
中選擇:- 對於未被掩碼的詞元,值為1,
- 對於被掩碼的詞元,值為0。
- bbox (
torch.LongTensor
,形狀為({0}, 4)
, optional) — 每個輸入序列詞元的邊界框。在 `[0, config.max_2d_position_embeddings-1]` 範圍內選擇。每個邊界框應為 (x0, y0, x1, y1) 格式的歸一化版本,其中 (x0, y0) 對應邊界框左上角的位置,(x1, y1) 表示右下角的位置。注意,`sequence_length = token_sequence_length + patch_sequence_length + 1`,其中 `1` 是為 [CLS] 詞元。關於 `patch_sequence_length`,請參見 `pixel_values`。
- pixel_values (
torch.Tensor
,形狀為(batch_size, num_channels, image_size, image_size)
, optional) — 與輸入影像對應的張量。可以使用 `{image_processor_class}` 獲取畫素值。有關詳細資訊,請參閱 `{image_processor_class}.__call__`(`{processor_class}` 使用 `{image_processor_class}` 處理影像)。 - visual_bbox (
torch.LongTensor
,形狀為(batch_size, patch_sequence_length, 4)
, optional) — 影像中每個補丁的邊界框。如果未提供,將在模型中建立邊界框。 - decoder_input_ids (
torch.LongTensor
,形狀為(batch_size, target_sequence_length)
, optional) — 詞彙表中解碼器輸入序列詞元的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什麼是解碼器輸入ID? T5使用 `pad_token_id` 作為生成 `decoder_input_ids` 的起始詞元。如果使用 `past_key_values`,可以選擇只輸入最後的 `decoder_input_ids`(參見 `past_key_values`)。要了解如何為預訓練準備 `decoder_input_ids`,請參閱 T5訓練。 - decoder_attention_mask (
torch.BoolTensor
,形狀為(batch_size, target_sequence_length)
, optional) — 預設行為:生成一個忽略 `decoder_input_ids` 中填充詞元的張量。預設情況下也會使用因果掩碼。 - inputs_embeds (
torch.Tensor
,形狀為(batch_size, sequence_length, hidden_size)
, optional) — 可選地,您可以選擇直接傳遞嵌入表示,而不是傳遞 `input_ids`。如果您希望比模型內部的嵌入查詢矩陣更好地控制如何將 `input_ids` 索引轉換為關聯向量,這將非常有用。 - encoder_outputs (
torch.Tensor
, optional) — 元組,包含 (`last_hidden_state`, optional: `hidden_states`, optional: `attentions`)。`last_hidden_state` 的形狀為 `(batch_size, sequence_length, hidden_size)`,optional) 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - past_key_values (
torch.Tensor
, optional) — 預計算的隱藏狀態(自注意力塊和交叉注意力塊中的鍵和值),可用於加速順序解碼。這通常是在解碼的先前階段,當 `use_cache=True` 或 `config.use_cache=True` 時,由模型返回的 `past_key_values`。允許兩種格式:
- 一個 Cache 例項,請參閱我們的 kv 快取指南;
- 長度為 `config.n_layers` 的 `tuple(torch.FloatTensor)` 的元組,每個元組有兩個形狀為 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的張量。這也稱為舊版快取格式。
模型將輸出與輸入相同的快取格式。如果未傳遞 `past_key_values`,將返回舊版快取格式。
如果使用 `past_key_values`,使用者可以選擇只輸入最後的 `input_ids`(那些沒有將其過去鍵值狀態提供給此模型的 `input_ids`),形狀為 `(batch_size, 1)`,而不是所有形狀為 `(batch_size, sequence_length)` 的 `input_ids`。
- head_mask (
torch.Tensor
,形狀為(num_heads,)
或(num_layers, num_heads)
, optional) — 用於將自注意力模組的選定頭部置零的掩碼。掩碼值在 `[0, 1]` 中選擇:- 1 表示頭部未被掩碼,
- 0 表示頭部被掩碼。
- decoder_inputs_embeds (
torch.Tensor
,形狀為(batch_size, target_sequence_length, hidden_size)
, optional) — 可選地,您可以選擇直接傳遞嵌入表示,而不是傳遞 `decoder_input_ids`。如果使用 `past_key_values`,可以選擇只輸入最後的 `decoder_inputs_embeds`(參見 `past_key_values`)。如果您希望比模型內部的嵌入查詢矩陣更好地控制如何將 `decoder_input_ids` 索引轉換為關聯向量,這將非常有用。如果 `decoder_input_ids` 和 `decoder_inputs_embeds` 都未設定,`decoder_inputs_embeds` 的值將取自 `inputs_embeds`。
- decoder_head_mask (
torch.FloatTensor
,形狀為(num_heads,)
或(num_layers, num_heads)
, optional) — 用於將解碼器中自注意力模組的選定頭部置零的掩碼。掩碼值在 `[0, 1]` 中選擇:- 1 表示頭部未被掩碼,
- 0 表示頭部被掩碼。
- cross_attn_head_mask (
torch.Tensor
,形狀為(num_heads,)
或(num_layers, num_heads)
, optional) — 用於將解碼器中交叉注意力模組的選定頭部置零的掩碼。掩碼值在 `[0, 1]` 中選擇:- 1 表示頭部未被掩碼,
- 0 表示頭部被掩碼。
- use_cache (`
, 預設為
True) -- 如果設定為
True,則返回
past_key_values` 鍵值狀態,可用於加速解碼(參見 `past_key_values`)。 - output_attentions (
bool
, optional) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的 `attentions`。 - output_hidden_states (
bool
, optional) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的 `hidden_states`。 - return_dict (
bool
, optional) — 是否返回一個 ModelOutput 而不是一個普通的元組。 - cache_position (
torch.LongTensor
,形狀為(sequence_length)
, optional) — 描繪輸入序列詞元在序列中位置的索引。與 `position_ids` 不同,此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。
UdopModel 的 forward 方法重寫了 `__call__` 特殊方法。
雖然前向傳播的配方需要在此函式內定義,但之後應該呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。
示例
>>> from transformers import AutoProcessor, AutoModel
>>> from datasets import load_dataset
>>> import torch
>>> # load model and processor
>>> # in this case, we already have performed OCR ourselves
>>> # so we initialize the processor with `apply_ocr=False`
>>> processor = AutoProcessor.from_pretrained("microsoft/udop-large", apply_ocr=False)
>>> model = AutoModel.from_pretrained("microsoft/udop-large")
>>> # load an example image, along with the words and coordinates
>>> # which were extracted using an OCR engine
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> inputs = processor(image, words, boxes=boxes, return_tensors="pt")
>>> decoder_input_ids = torch.tensor([[model.config.decoder_start_token_id]])
>>> # forward pass
>>> outputs = model(**inputs, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 1, 1024]
UdopForConditionalGeneration
class transformers.UdopForConditionalGeneration
< source >( config )
引數
- config (UdopForConditionalGeneration) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重,只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
UDOP 編碼器-解碼器 Transformer,頂部帶有語言建模頭,能夠在給定文件影像和可選提示的情況下生成文字。
該類基於 T5ForConditionalGeneration,並擴充套件以處理影像和佈局(2D)資料。
該模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為其所有模型實現的通用方法(例如下載或儲存、調整輸入嵌入大小、修剪頭部等)。
該模型也是 PyTorch torch.nn.Module 的子類。可以像常規 PyTorch 模組一樣使用它,並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None bbox: typing.Optional[dict[str, typing.Any]] = None pixel_values: typing.Optional[torch.Tensor] = None visual_bbox: typing.Optional[dict[str, typing.Any]] = None decoder_input_ids: typing.Optional[torch.Tensor] = None decoder_attention_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_inputs_embeds: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None use_cache = True output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels: typing.Optional[torch.Tensor] = None cache_position: typing.Optional[torch.LongTensor] = None )
引數
- input_ids (
torch.Tensor
,形狀為(batch_size, sequence_length)
, optional) — 詞彙表中輸入序列詞元的索引。預設情況下,填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊,請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor
,形狀為(batch_size, sequence_length)
, optional) — 用於避免對填充詞元索引執行注意力操作的掩碼。掩碼值在[0, 1]
中選擇:- 對於未被掩碼的詞元,值為1,
- 對於被掩碼的詞元,值為0。
- bbox (
torch.LongTensor
,形狀為({0}, 4)
, optional) — 每個輸入序列詞元的邊界框。在 `[0, config.max_2d_position_embeddings-1]` 範圍內選擇。每個邊界框應為 (x0, y0, x1, y1) 格式的歸一化版本,其中 (x0, y0) 對應邊界框左上角的位置,(x1, y1) 表示右下角的位置。注意,`sequence_length = token_sequence_length + patch_sequence_length + 1`,其中 `1` 是為 [CLS] 詞元。關於 `patch_sequence_length`,請參見 `pixel_values`。
- pixel_values (
torch.Tensor
,形狀為(batch_size, num_channels, image_size, image_size)
, optional) — 與輸入影像對應的張量。可以使用 `{image_processor_class}` 獲取畫素值。有關詳細資訊,請參閱 `{image_processor_class}.__call__`(`{processor_class}` 使用 `{image_processor_class}` 處理影像)。 - visual_bbox (
torch.LongTensor
,形狀為(batch_size, patch_sequence_length, 4)
, optional) — 影像中每個補丁的邊界框。如果未提供,將在模型中建立邊界框。 - decoder_input_ids (
torch.LongTensor
,形狀為(batch_size, target_sequence_length)
,可選) — 解碼器輸入序列在詞彙表中的 token 索引。索引可以使用 AutoTokenizer 獲取。有關詳細資訊,請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什麼是解碼器輸入 ID? T5 使用pad_token_id
作為生成decoder_input_ids
的起始 token。如果使用past_key_values
,可以選擇只輸入最後一個decoder_input_ids
(參見past_key_values
)。要了解更多關於如何為預訓練準備decoder_input_ids
的資訊,請參閱 T5 訓練。 - decoder_attention_mask (
torch.BoolTensor
,形狀為(batch_size, target_sequence_length)
,可選) — 預設行為:生成一個忽略decoder_input_ids
中填充 token 的張量。預設情況下也會使用因果掩碼。 - inputs_embeds (
torch.Tensor
,形狀為(batch_size, sequence_length, hidden_size)
,可選) — 可選地,你可以不傳遞input_ids
,而是直接傳遞一個嵌入表示。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids
索引轉換為關聯向量,這會很有用。 - encoder_outputs (
torch.Tensor
,可選) — 元組,包含 (last_hidden_state
, 可選:hidden_states
, 可選:attentions
)。形狀為(batch_size, sequence_length, hidden_size)
的last_hidden_state
(可選)是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力機制。 - past_key_values (
torch.Tensor
,可選) — 預先計算的隱藏狀態(自注意力塊和交叉注意力塊中的鍵和值),可用於加速序列解碼。這通常包括模型在解碼的前一個階段返回的past_key_values
,此時use_cache=True
或config.use_cache=True
。允許兩種格式:
- 一個 Cache 例項,請參閱我們的 kv 快取指南;
- 一個長度為
config.n_layers
的tuple(torch.FloatTensor)
元組,每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)
的張量)。這也稱為傳統快取格式。
模型將輸出與輸入相同的快取格式。如果沒有傳遞
past_key_values
,將返回傳統快取格式。如果使用了
past_key_values
,使用者可以選擇只輸入最後一個input_ids
(那些沒有給出其過去鍵值狀態的 token),其形狀為(batch_size, 1)
,而不是所有形狀為(batch_size, sequence_length)
的input_ids
。 - head_mask (
torch.Tensor
,形狀為(num_heads,)
或(num_layers, num_heads)
,可選) — 用於置零自注意力模組中選定頭的掩碼。掩碼值選自[0, 1]
:- 1 表示頭未被遮蓋,
- 0 表示頭被遮蓋。
- decoder_inputs_embeds (
torch.Tensor
,形狀為(batch_size, target_sequence_length, hidden_size)
,可選) — 可選地,你可以不傳遞decoder_input_ids
,而是直接傳遞一個嵌入表示。如果使用past_key_values
,可以選擇只輸入最後一個decoder_inputs_embeds
(參見past_key_values
)。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將decoder_input_ids
索引轉換為關聯向量,這會很有用。如果
decoder_input_ids
和decoder_inputs_embeds
都未設定,decoder_inputs_embeds
將取inputs_embeds
的值。 - decoder_head_mask (
torch.FloatTensor
,形狀為(num_heads,)
或(num_layers, num_heads)
,可選) — 用於置零解碼器中自注意力模組選定頭的掩碼。掩碼值選自[0, 1]
:- 1 表示頭未被遮蓋,
- 0 表示頭被遮蓋。
- cross_attn_head_mask (
torch.Tensor
,形狀為(num_heads,)
或(num_layers, num_heads)
,可選) — 用於置零解碼器中交叉注意力模組選定頭的掩碼。掩碼值選自[0, 1]
:- 1 表示頭未被遮蓋,
- 0 表示頭被遮蓋。
- use_cache (`
,預設為
True) -- 如果設定為
True,將返回
past_key_values` 的鍵值狀態,可用於加速解碼(參見 `past_key_values`)。 - output_attentions (
bool
,可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的attentions
。 - output_hidden_states (
bool
,可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的hidden_states
。 - return_dict (
bool
,可選) — 是否返回 ModelOutput 而不是普通的元組。 - labels (
torch.LongTensor
,形狀為(batch_size,)
,可選) — 用於計算語言建模損失的標籤。索引應在[-100, 0, ..., config.vocab_size - 1]
範圍內。所有設定為-100
的標籤都會被忽略(遮蓋),損失僅對[0, ..., config.vocab_size]
範圍內的標籤進行計算。 - cache_position (
torch.LongTensor
,形狀為(sequence_length)
,可選) — 描繪輸入序列 token 在序列中位置的索引。與position_ids
相反,此張量不受填充影響。它用於在正確的位置更新快取並推斷完整的序列長度。
UdopForConditionalGeneration 的 forward 方法覆蓋了 __call__
特殊方法。
雖然前向傳播的配方需要在此函式內定義,但之後應該呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。
示例
>>> from transformers import AutoProcessor, UdopForConditionalGeneration
>>> from datasets import load_dataset
>>> # load model and processor
>>> # in this case, we already have performed OCR ourselves
>>> # so we initialize the processor with `apply_ocr=False`
>>> processor = AutoProcessor.from_pretrained("microsoft/udop-large", apply_ocr=False)
>>> model = UdopForConditionalGeneration.from_pretrained("microsoft/udop-large")
>>> # load an example image, along with the words and coordinates
>>> # which were extracted using an OCR engine
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> # one can use the various task prefixes (prompts) used during pre-training
>>> # e.g. the task prefix for DocVQA is "Question answering. "
>>> question = "Question answering. What is the date on the form?"
>>> encoding = processor(image, question, text_pair=words, boxes=boxes, return_tensors="pt")
>>> # autoregressive generation
>>> predicted_ids = model.generate(**encoding)
>>> print(processor.batch_decode(predicted_ids, skip_special_tokens=True)[0])
9/30/92
UdopEncoderModel
class transformers.UdopEncoderModel
< 來源 >( config: UdopConfig )
引數
- config (UdopConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型關聯的權重,只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
基礎的 Udop 模型,輸出原始的隱藏狀態,頂部沒有任何特定的頭。
該模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為其所有模型實現的通用方法(例如下載或儲存、調整輸入嵌入大小、修剪頭部等)。
該模型也是 PyTorch torch.nn.Module 的子類。可以像常規 PyTorch 模組一樣使用它,並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< 來源 >( input_ids: typing.Optional[torch.Tensor] = None bbox: typing.Optional[dict[str, typing.Any]] = None attention_mask: typing.Optional[torch.Tensor] = None pixel_values: typing.Optional[torch.Tensor] = None visual_bbox: typing.Optional[dict[str, typing.Any]] = 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.models.udop.modeling_udop.BaseModelOutputWithAttentionMask
或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor
,形狀為(batch_size, sequence_length)
) — 輸入序列在詞彙表中的 token 索引。T5 是一個帶有相對位置嵌入的模型,因此你應該能夠對輸入的左右兩邊進行填充。索引可以使用 AutoTokenizer 獲取。有關詳細資訊,請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
要了解更多關於如何為預訓練準備
input_ids
的資訊,請參閱 T5 訓練。 - bbox (
torch.LongTensor
,形狀為({0}, 4)
,可選) — 每個輸入序列 token 的邊界框。選擇範圍在[0, config.max_2d_position_embeddings-1]
。每個邊界框應為 (x0, y0, x1, y1) 格式的歸一化版本,其中 (x0, y0) 對應邊界框左上角的位置,(x1, y1) 表示右下角的位置。請注意,
sequence_length = token_sequence_length + patch_sequence_length + 1
,其中1
是 [CLS] token。有關patch_sequence_length
,請參閱pixel_values
。 - attention_mask (
torch.Tensor
,形狀為(batch_size, sequence_length)
,可選) — 用於避免對填充 token 索引執行注意力的掩碼。掩碼值選自[0, 1]
:- 1 表示 token 未被遮蓋,
- 0 表示 token 被遮蓋。
- pixel_values (
torch.Tensor
,形狀為(batch_size, num_channels, image_size, image_size)
,可選) — 對應於輸入影像的張量。畫素值可以使用{image_processor_class}
獲取。有關詳細資訊,請參閱{image_processor_class}.__call__
({processor_class}
使用{image_processor_class}
處理影像)。 - visual_bbox (
torch.LongTensor
,形狀為(batch_size, patch_sequence_length, 4)
,可選) — 影像中每個補丁的邊界框。如果未提供,則在模型中建立邊界框。 - 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
索引轉換為關聯向量,這會很有用。 - output_attentions (
bool
,可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊,請參閱返回張量下的attentions
。 - output_hidden_states (
bool
,可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊,請參閱返回張量下的hidden_states
。 - return_dict (
bool
,可選) — 是否返回 ModelOutput 而不是普通的元組。
返回
transformers.models.udop.modeling_udop.BaseModelOutputWithAttentionMask
或 tuple(torch.FloatTensor)
一個 transformers.models.udop.modeling_udop.BaseModelOutputWithAttentionMask
或一個 torch.FloatTensor
元組(如果傳遞了 return_dict=False
或 config.return_dict=False
),根據配置(UdopConfig)和輸入,包含不同的元素。
- last_hidden_state (
torch.FloatTensor
,形狀為(batch_size, sequence_length, hidden_size)
) — 模型最後一層輸出的隱藏狀態序列。如果使用past_key_values
,則只輸出序列的最後一個隱藏狀態,形狀為(batch_size, 1, hidden_size)
。 - attention_mask (
torch.FloatTensor
,形狀為(batch_size, sequence_length)
,可選) — 在模型的前向傳播中使用的注意力掩碼,用於避免對填充 token 索引執行注意力。掩碼值選自[0, 1]
— - 1 表示 token 未被遮蓋,- 0 代表**被掩碼**的標記。
- past_key_values (
tuple(tuple(torch.FloatTensor))
,可選,在傳遞use_cache=True
或config.use_cache=True
時返回) — 長度為config.n_layers
的tuple(torch.FloatTensor)
元組,每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)
的張量,如果config.is_encoder_decoder=True
,則可選地包含 2 個額外的形狀為(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的張量。包含預計算的隱藏狀態(自注意力塊中的鍵和值,如果config.is_encoder_decoder=True
則可選地包含交叉注意力塊中的鍵和值),可用於(參見past_key_values
輸入)加速序列解碼。 - 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 之後,用於在交叉注意力頭中計算加權平均值。
UdopEncoderModel 的 forward 方法覆蓋了 __call__
特殊方法。
雖然前向傳播的配方需要在此函式內定義,但之後應該呼叫 `Module` 例項而不是此函式,因為前者會處理執行前處理和後處理步驟,而後者會靜默地忽略它們。
示例
>>> from transformers import AutoProcessor, UdopEncoderModel
>>> from huggingface_hub import hf_hub_download
>>> from datasets import load_dataset
>>> # load model and processor
>>> # in this case, we already have performed OCR ourselves
>>> # so we initialize the processor with `apply_ocr=False`
>>> processor = AutoProcessor.from_pretrained("microsoft/udop-large", apply_ocr=False)
>>> model = UdopEncoderModel.from_pretrained("microsoft/udop-large")
>>> # load an example image, along with the words and coordinates
>>> # which were extracted using an OCR engine
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> encoding = processor(image, words, boxes=boxes, return_tensors="pt")
>>> outputs = model(**encoding)
>>> last_hidden_states = outputs.last_hidden_state