ZjԟrSrSSKJr SSKrSSKJr SSKJrJrJr SSK J r SSK J r SS KJr SS KJrJrJrJrJrJr SS KJrJr SS KJr SS KJr SSKJrJ r J!r!J"r" SSK#J$r$ SSK%J&r& SSK'J(r( \"RR"\*5r+\RXr-"SS\R\5r/SCS\R\S\R`S\R`S\R`S\R`S-S\1S\14Sjjr2"SS\R\5r3"SS \R\5r4"S!S"\R\5r5"S#S$\R\5r6"S%S&\R\5r7"S'S(\5r8"S)S*\R\5r9"S+S,\R\5r:"S-S.\R\5r;"S/S0\R\5r<"S1S2\R\5r=\ "S3S4\55r>\ "S5S6\>55r?\ "S7S8\>55r@\ "S9S:9"S;S<\>55rA\ "S=S:9"S>S?\>55rB\ "S@SA\>55rC/SBQrDg)DzPyTorch LayoutLM model.)CallableN)nn)BCEWithLogitsLossCrossEntropyLossMSELoss)initialization)ACT2FN)GradientCheckpointingLayer)BaseModelOutputBaseModelOutputWithPoolingMaskedLMOutputQuestionAnsweringModelOutputSequenceClassifierOutputTokenClassifierOutput)ALL_ATTENTION_FUNCTIONSPreTrainedModel)Unpack)apply_chunking_to_forward)TransformersKwargsauto_docstringcan_return_tuplelogging)merge_with_config_defaults)capture_outputs)LayoutLMConfigc@^\rSrSrSrU4SjrSSjrSrU=r$)LayoutLMEmbeddings0zGConstruct the embeddings from word, position and token_type embeddings.c>[TU]5 [R"URUR UR S9Ul[R"URUR 5Ul [R"URUR 5Ul [R"URUR 5Ul [R"URUR 5Ul [R"URUR 5Ul[R"URUR 5Ul[#UR UR$S9Ul[R("UR*5UlUR/S[0R2"UR5R5S5SS9 g)N) padding_idxeps position_idsrF) persistent)super__init__r Embedding vocab_size hidden_size pad_token_idword_embeddingsmax_position_embeddingsposition_embeddingsmax_2d_position_embeddingsx_position_embeddingsy_position_embeddingsh_position_embeddingsw_position_embeddingstype_vocab_sizetoken_type_embeddingsLayoutLMLayerNormlayer_norm_eps LayerNormDropouthidden_dropout_probdropoutregister_buffertorcharangeexpandselfconfig __class__s /root/GenerationalWealth/GenerationalWealth/venv/lib/python3.13/site-packages/transformers/models/layoutlm/modeling_layoutlm.pyr*LayoutLMEmbeddings.__init__3s[ !||F,=,=v?Q?Q_e_r_rs#%<<0N0NPVPbPb#c %'\\&2S2SU[UgUg%h"%'\\&2S2SU[UgUg%h"%'\\&2S2SU[UgUg%h"%'\\&2S2SU[UgUg%h"%'\\&2H2H&J\J\%]"*6+=+=6CXCXYzz&"<"<=   ELL)G)GHOOPWXej  cUbUR5nOUR5SSnUSnUb URO URnUcURSS2SU24nUc$[R"U[R US9nUcUR U5nUn URU5n URUSS2SS2S45n URUSS2SS2S45n URUSS2SS2S45n URUSS2SS2S45nURUSS2SS2S4USS2SS2S4- 5nURUSS2SS2S4USS2SS2S4- 5nURU5nU U -U -U -U -U-U-U-U-nURU5nURU5nU$![an[S5UeSnAff=f)Nr'rdtypedevicerrz:The `bbox`coordinate values should be within 0-1000 range.)sizerMr%r@zeroslongr/r1r3r4 IndexErrorr5r6r8r;r>)rD input_idsbboxtoken_type_idsr% inputs_embeds input_shape seq_lengthrMwords_embeddingsr1left_position_embeddingsupper_position_embeddingsright_position_embeddingslower_position_embeddingser5r6r8 embeddingss rGforwardLayoutLMEmbeddings.forwardDs1  #..*K',,.s3K ^ %.%:!! @T@T  ,,Q  ^ J ! "& '( ((  ( (  ( $  $$ $$ $ ^^J/ \\*- ) bYZ`a a bs/A,F:: G GG) r;r>r5r1r8r6r/r3r4)NNNNN) __name__ __module__ __qualname____firstlineno____doc__r*r`__static_attributes__ __classcell__rFs@rGrr0s&Q &  55rIrmodulequerykeyvalueattention_maskscalingr>c [R"XRSS55U-nUbX-n[RR US[R S9RUR5n[RRXURS9n[R"X5n U RSS5R5n X4$)NrNrr')dimrL)ptrainingr) r@matmul transposer functionalsoftmaxfloat32torLr>rs contiguous) rjrkrlrmrnror>kwargs attn_weights attn_outputs rGeager_attention_forwardr~}s<<}}Q':;gEL!#4 ==((2U]](SVVW\WbWbcL==((6??([L,,|3K''1-88:K  $$rIc ^\rSrSrU4SjrS S\R S\RS-S\\ S\ \R \R S-44Sjjr S r U=r $) LayoutLMSelfAttentionc6>[TU]5 URUR-S:wa7[ US5(d&[ SURSURS35eXlURUl[URUR- 5UlURUR-Ul [R"URUR5Ul [R"URUR5Ul [R"URUR5Ul[R"UR 5UlUR UlURS-Ulg)Nrembedding_sizezThe hidden size (z6) is not a multiple of the number of attention heads ()g)r)r*r-num_attention_headshasattr ValueErrorrEintattention_head_size all_head_sizerLinearrkrlrmr<attention_probs_dropout_probr>attention_dropoutrorCs rGr*LayoutLMSelfAttention.__init__sD     : : :a ?PVXhHiHi#F$6$6#78 445Q8   #)#=#= #&v'9'9Fro)shaperrkviewrurlrmr get_interfacerE_attn_implementationr~rsrroreshaperz) rDrrnr{rW hidden_shape query_states key_states value_statesattention_interfacer}r|s rGr`LayoutLMSelfAttention.forwards8 $))#2. CCbC$*B*BC zz-055lCMMaQRS XXm,11,?II!QO zz-055lCMMaQRS (?(M(M KK , ,.E) %8      % $}}C$2H2HLL %  % ! "));;;;FFH ((rI) rrrrEr>rlrrkrormN)rbrcrdrer*r@Tensor FloatTensorrrtupler`rgrhris@rGrrsi6048)||)))D0)+, ) u||U\\D00 1 ))rIrcz^\rSrSrU4SjrS\R S\R S\R 4SjrSrU=r $)LayoutLMSelfOutputc(>[TU]5 [R"URUR5Ul[R "URURS9Ul[R"UR5Ul gNr#) r)r*rrr-denser;r:r<r=r>rCs rGr*LayoutLMSelfOutput.__init__s` YYv1163E3EF f&8&8f>S>STzz&"<"<= rIr input_tensorrcpURU5nURU5nURX-5nU$rrr>r;rDrrs rGr`LayoutLMSelfOutput.forward5 =1  ]3 }'CD rIr;rr> rbrcrdrer*r@rr`rgrhris@rGrr6> U\\RWR^R^rIrc ^\rSrSrU4SjrS S\R S\RS-S\\ S\R 4Sjjr S r U=r $) LayoutLMAttentioncb>[TU]5 [U5Ul[ U5Ulgr)r)r*rrDroutputrCs rGr*LayoutLMAttention.__init__s& )&1 (0 rINrrnr{rc ZUnUR"U4SU0UD6upURX5nU$Nrn)rDr)rDrrnr{residual_s rGr`LayoutLMAttention.forwardsE !99  )    M< rI)rrDr) rbrcrdrer*r@rrrrr`rgrhris@rGrrsV148 || ))D0 +,    rIrcb^\rSrSrU4SjrS\R S\R 4SjrSrU=r $)LayoutLMIntermediatec>[TU]5 [R"URUR 5Ul[UR[5(a[URUl gURUl gr) r)r*rrr-intermediate_sizer isinstance hidden_actstrr intermediate_act_fnrCs rGr*LayoutLMIntermediate.__init__s` YYv1163K3KL f'' - -'-f.?.?'@D $'-'8'8D $rIrrcJURU5nURU5nU$rrrrDrs rGr`LayoutLMIntermediate.forwards& =1 00? rIrrris@rGrrs(9U\\ellrIrcz^\rSrSrU4SjrS\R S\R S\R 4SjrSrU=r $)LayoutLMOutputic(>[TU]5 [R"URUR 5Ul[R"UR URS9Ul[R"UR5Ul gr) r)r*rrrr-rr;r:r<r=r>rCs rGr*LayoutLMOutput.__init__s` YYv779K9KL f&8&8f>S>STzz&"<"<= rIrrrcpURU5nURU5nURX-5nU$rrrs rGr`LayoutLMOutput.forwardrrIrrris@rGrrrrIrc ^\rSrSrU4SjrS S\R S\RS-S\\ S\R 4Sjjr S r S r U=r $) LayoutLMLayeric>[TU]5 URUlSUl[ U5Ul[ U5Ul[U5Ul g)Nr) r)r*chunk_size_feed_forward seq_len_dimr attentionr intermediaterrrCs rGr*LayoutLMLayer.__init__sI '-'E'E$*6208$V, rINrrnr{rc UR"U4SU0UD6n[URURURU5nU$r)rrfeed_forward_chunkrr)rDrrnr{s rGr`LayoutLMLayer.forwardsW   )  2  # #T%A%A4CSCSUb rIcJURU5nURX!5nU$r)rr)rDattention_outputintermediate_output layer_outputs rGr LayoutLMLayer.feed_forward_chunk+s)"//0@A{{#6I rI)rrrrrr)rbrcrdrer*r@rrrrr`rrgrhris@rGrrs[-48||))D0+,   $rIrc |^\rSrSrU4SjrS S\R S\RS-S\\ S\ 4Sjjr S r U=r $) LayoutLMEncoderi2c>[TU]5 Xl[R"[ UR 5Vs/sHn[U5PM sn5UlSUl gs snf)NF) r)r*rEr ModuleListrangenum_hidden_layersrlayergradient_checkpointing)rDrEirFs rGr*LayoutLMEncoder.__init__3sR  ]]5IaIaCb#cCbaM&$9Cb#cd &+#$dsA&Nrrnr{rc NURH nU"UU40UD6nM [US9$)N)last_hidden_state)rr )rDrrnr{ layer_modules rGr`LayoutLMEncoder.forward9s> !JJL(M'+  rI)rErrr)rbrcrdrer*r@rrrrr r`rgrhris@rGrr2sR,48 || ))D0 +,     rIrcb^\rSrSrU4SjrS\R S\R 4SjrSrU=r $)LayoutLMPooleriLc>[TU]5 [R"URUR5Ul[R "5Ulgr)r)r*rrr-rTanh activationrCs rGr*LayoutLMPooler.__init__Ms9 YYv1163E3EF '')rIrrc\USS2S4nURU5nURU5nU$)Nr)rr)rDrfirst_token_tensor pooled_outputs rGr`LayoutLMPooler.forwardRs6+1a40 #56  6 rI)rrrris@rGrrLs($ U\\ellrIrcb^\rSrSrU4SjrS\R S\R 4SjrSrU=r $)LayoutLMPredictionHeadTransformi\cp>[TU]5 [R"URUR5Ul[ UR[5(a[URUl OURUl [R"URURS9Ul gr) r)r*rrr-rrrrr transform_act_fnr;r:rCs rGr*(LayoutLMPredictionHeadTransform.__init__]s~ YYv1163E3EF f'' - -$*6+<+<$=D !$*$5$5D !f&8&8f>S>STrIrrclURU5nURU5nURU5nU$r)rrr;rs rGr`'LayoutLMPredictionHeadTransform.forwardfs4 =1 --m< }5 rI)r;rrrris@rGrr\s)UU\\ellrIrc.^\rSrSrU4SjrSrSrU=r$)LayoutLMLMPredictionHeadinc>[TU]5 [U5Ul[R "UR URSS9Ul[R"[R"UR55Ul g)NT)bias) r)r*r transformrrr-r,decoder Parameterr@rPrrCs rGr*!LayoutLMLMPredictionHead.__init__os[ 8@yy!3!3V5F5FTR LLV->->!?@ rIcJURU5nURU5nU$r)rrrs rGr` LayoutLMLMPredictionHead.forwardxs$}5  ]3 rI)rrr)rbrcrdrer*r`rgrhris@rGrrnsArIrcb^\rSrSrU4SjrS\R S\R 4SjrSrU=r $)LayoutLMOnlyMLMHeadicB>[TU]5 [U5Ulgr)r)r*r predictionsrCs rGr*LayoutLMOnlyMLMHead.__init__s 3F;rIsequence_outputrc(URU5nU$rr )rDrprediction_scoress rGr`LayoutLMOnlyMLMHead.forwards ,,_=  rIrrris@rGr r s(<!u||! !!rIr cn^\rSrSr%\\S'SrSr\\ S.r \ R"5U4Sj5r SrU=r$)LayoutLMPreTrainedModelirElayoutlmT)r attentionscr>[TU]U5 [U[5(a![R "UR 5 g[U[5(a\[R"UR[R"URRS5RS55 gg)zInitialize the weightsr'r&N)r) _init_weightsrrinitzeros_rrcopy_r%r@rArrB)rDrjrFs rGr%LayoutLMPreTrainedModel._init_weightss~ f% f6 7 7 KK $  2 3 3 JJv**ELL9L9L9R9RSU9V,W,^,^_f,g h4rI)rbrcrdrer__annotations__base_model_prefixsupports_gradient_checkpointingrr_can_record_outputsr@no_gradrrgrhris@rGrrs? "&*#&+  ]]_iirIrc4^\rSrSrU4SjrSrSr\\\ SS\ RS-S\ RS-S\ RS-S \ RS-S \ RS-S \ RS-S \ \S \\-4Sjj555rSrU=r$) LayoutLMModelic>[TU]U5 Xl[U5Ul[ U5Ul[U5UlUR5 gr) r)r*rErr_rencoderrpooler post_initrCs rGr*LayoutLMModel.__init__sE   ,V4&v. $V,  rIc.URR$rr_r/rDs rGget_input_embeddings"LayoutLMModel.get_input_embeddingss...rIc$XRlgrr,)rDrms rGset_input_embeddings"LayoutLMModel.set_input_embeddingss */'rINrSrTrnrUr%rVr{rc UbUb [S5eUb"URX5 UR5nO"UbUR5SSnO [S5eUb URO URn Uc[R "XS9nUc$[R "U[RU S9nUc'[R "US-[RU S9nURS5RS 5n U RURS 9n S U - [R"UR5R-n URUUUUUS 9n UR"U U 40UD6n U S n URU 5n[!U US9$)a bbox (`torch.LongTensor` of shape `(batch_size, sequence_length, 4)`, *optional*): Bounding boxes of each input sequence tokens. Selected in the range `[0, config.max_2d_position_embeddings-1]`. Each bounding box should be a normalized version in (x0, y0, x1, y1) format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1, y1) represents the position of the lower right corner. See [Overview](#Overview) for normalization. Examples: ```python >>> 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 ```NzDYou cannot specify both input_ids and inputs_embeds at the same timer'z5You have to specify either input_ids or inputs_embeds)rMrK)rrN)rLg?)rSrTr%rUrVr)r pooler_output)r%warn_if_padding_and_no_attention_maskrOrMr@onesrPrQ unsqueezeryrLfinfominr_r'r(r )rDrSrTrnrUr%rVr{rWrMextended_attention_maskembedding_outputencoder_outputsrrs rGr`LayoutLMModel.forwardsf  ]%>cd d  "  6 6y Q#..*K  &',,.s3KTU U%.%:!! @T@T  !"ZZ CN  !"[[EJJvVN <;;{T1FSD"0":":1"="G"G"J"9"<"<4::"<"N#&)@#@EKKPTPZPZD[D_D_"_??%)' + ,,  #   *!, O4 )-'  rI)rEr_r'r()NNNNNN)rbrcrdrer*r.r1rrrr@ LongTensorrrrrr r`rgrhris@rGr%r%s /0 .2(,37260426[ ##d*[ %[ ))D0 [ ((4/ [ &&- [ ((4/[ +,[  + +[  [ rIr%cZ^\rSrSrSSS.rU4SjrSrSrSr\ \ SS \ RS -S \ RS -S \ RS -S \ RS -S\ RS -S\ RS -S\ RS -S\\S\\-4Sjj55rSrU=r$)LayoutLMForMaskedLMizcls.predictions.biasz*layoutlm.embeddings.word_embeddings.weight)zcls.predictions.decoder.biaszcls.predictions.decoder.weightc>[TU]U5 [U5Ul[ U5UlUR 5 gr)r)r*r%rr clsr)rCs rGr*LayoutLMForMaskedLM.__init__s4  %f- &v. rIcBURRR$rrr_r/r-s rGr.(LayoutLMForMaskedLM.get_input_embeddings!}}''777rIcBURRR$r)rCr rr-s rGget_output_embeddings)LayoutLMForMaskedLM.get_output_embeddings$sxx##+++rIcXRRlURURRlgr)rCr rr)rDnew_embeddingss rGset_output_embeddings)LayoutLMForMaskedLM.set_output_embeddings's*'5$$2$7$7!rINrSrTrnrUr%rVlabelsr{rc 6UR"UU4UUUUS.UD6n U Sn URU 5n Sn UbF[5n U "U RSURR 5URS55n [ U U U RU RS9$)a bbox (`torch.LongTensor` of shape `(batch_size, sequence_length, 4)`, *optional*): Bounding boxes of each input sequence tokens. Selected in the range `[0, config.max_2d_position_embeddings-1]`. Each bounding box should be a normalized version in (x0, y0, x1, y1) format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1, y1) represents the position of the lower right corner. See [Overview](#Overview) for normalization. labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked language modeling loss. Indices should be in `[-100, 0, ..., config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]` Examples: ```python >>> 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 ```)rnrUr%rVrNr'losslogitsrr) rrCrrrEr,rrr)rDrSrTrnrUr%rVrPr{outputsrrmasked_lm_lossloss_fcts rGr`LayoutLMForMaskedLM.forward+sz--   *)%'   "!* HH_5  ')H%!&&r4;;+A+AB BN $!//))   rI)rCrNNNNNNN)rbrcrdre_tied_weights_keysr*r.rJrNrrr@r?rrrrrr`rgrhris@rGrArAs)?*V 8,8.2(,37260426*.U ##d*U %U ))D0 U ((4/ U &&- U ((4/U   4'U +,U   U U rIrAz LayoutLM Model with a sequence classification head on top (a linear layer on top of the pooled output) e.g. for document image classification tasks such as the [RVL-CDIP](https://www.cs.cmu.edu/~aharley/rvl-cdip/) dataset. ) custom_introcD^\rSrSrU4SjrSr\\SS\RS-S\RS-S\RS-S\RS-S \RS-S \RS-S \RS-S \ \ S \ \-4Sjj55rSrU=r$)!LayoutLMForSequenceClassificationic0>[TU]U5 URUl[U5Ul[ R "UR5Ul[ R"URUR5Ul UR5 gr r)r* num_labelsr%rrr<r=r>rr- classifierr)rCs rGr**LayoutLMForSequenceClassification.__init__i   ++%f- zz&"<"<= ))F$6$68I8IJ rIcBURRR$rrFr-s rGr.6LayoutLMForSequenceClassification.get_input_embeddingsrHrINrSrTrnrUr%rVrPr{rc UR"S UUUUUUS.UD6n U Sn URU 5n URU 5n Sn UGbURRcUR S:XaSURlOoUR S:aNUR [R:XdUR [R:XaSURlOSURlURRS:XaI[5n UR S:Xa&U "U R5UR55n OU "X5n OURRS:Xa=[5n U "U RSUR 5URS55n O,URRS:Xa[5n U "X5n [U U U R U R"S9$) a  bbox (`torch.LongTensor` of shape `(batch_size, sequence_length, 4)`, *optional*): Bounding boxes of each input sequence tokens. Selected in the range `[0, config.max_2d_position_embeddings-1]`. Each bounding box should be a normalized version in (x0, y0, x1, y1) format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1, y1) represents the position of the lower right corner. See [Overview](#Overview) for normalization. labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*): Labels for computing the sequence classification/regression loss. Indices should be in `[0, ..., config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If `config.num_labels > 1` a classification loss is computed (Cross-Entropy). Examples: ```python >>> 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 ```rSrTrnrUr%rVrN regressionsingle_label_classificationmulti_label_classificationr'rRr)rr>rarE problem_typer`rLr@rQrrsqueezerrrrrr)rDrSrTrnrUr%rVrPr{rUrrTrSrWs rGr`)LayoutLMForSequenceClassification.forwardsz-- ))%'      ]3 /  {{''/??a'/;DKK,__q(fllejj.HFLL\a\e\eLe/LDKK,/KDKK,{{''<7"9??a'#FNN$4fnn6FGD#F3D))-JJ+- B @&++b/R))-II,./'!//))   rIrar>rr`rY)rbrcrdrer*r.rrr@r?rrrrrr`rgrhris@rGr]r]s8.2(,37260426*.f ##d*f %f ))D0 f ((4/ f &&- f ((4/f   4'f +,f  ) )f f rIr]a3 LayoutLM Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for sequence labeling (information extraction) tasks such as the [FUNSD](https://guillaumejaume.github.io/FUNSD/) dataset and the [SROIE](https://rrc.cvc.uab.es/?ch=13) dataset. cD^\rSrSrU4SjrSr\\SS\RS-S\RS-S\RS-S\RS-S \RS-S \RS-S \RS-S \ \ S \ \-4Sjj55rSrU=r$)LayoutLMForTokenClassificationic0>[TU]U5 URUl[U5Ul[ R "UR5Ul[ R"URUR5Ul UR5 grr_rCs rGr*'LayoutLMForTokenClassification.__init__ rcrIcBURRR$rrFr-s rGr.3LayoutLMForTokenClassification.get_input_embeddingsrHrINrSrTrnrUr%rVrPr{rc DUR"SUUUUUUS.UD6n U Sn URU 5n URU 5n Sn Ub<[5n U "U R SUR 5UR S55n [ U U U RU RS9$)a bbox (`torch.LongTensor` of shape `(batch_size, sequence_length, 4)`, *optional*): Bounding boxes of each input sequence tokens. Selected in the range `[0, config.max_2d_position_embeddings-1]`. Each bounding box should be a normalized version in (x0, y0, x1, y1) format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1, y1) represents the position of the lower right corner. See [Overview](#Overview) for normalization. labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`. Examples: ```python >>> 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 ```rgrNr'rRr) rr>rarrr`rrr)rDrSrTrnrUr%rVrPr{rUrrTrSrWs rGr`&LayoutLMForTokenClassification.forwardsv-- ))%'   "!*,,71  ')HFKKDOO[TU]U5 URUl[U5Ul[ R "URUR5UlUR5 g)z} has_visual_segment_embedding (`bool`, *optional*, defaults to `True`): Whether or not to add visual segment embeddings. N) r)r*r`r%rrrr- qa_outputsr))rDrEhas_visual_segment_embeddingrFs rGr*%LayoutLMForQuestionAnswering.__init__rsU   ++%f- ))F$6$68I8IJ rIcBURRR$rrFr-s rGr.1LayoutLMForQuestionAnswering.get_input_embeddingsrHrINrSrTrnrUr%rVstart_positions end_positionsr{rc UR"S UUUUUUS.U D6n U Sn URU 5n U RSSS9upU RS5R 5n URS5R 5nSnUbUb[ UR 55S:aURS5n[ UR 55S:aURS5nU R S5nURSU5nURSU5n[US9nU"X5nU"X5nUU-S- n[UU UU RU RS 9$) a bbox (`torch.LongTensor` of shape `(batch_size, sequence_length, 4)`, *optional*): Bounding boxes of each input sequence tokens. Selected in the range `[0, config.max_2d_position_embeddings-1]`. Each bounding box should be a normalized version in (x0, y0, x1, y1) format, where (x0, y0) corresponds to the position of the upper left corner in the bounding box, and (x1, y1) represents the position of the lower right corner. See [Overview](#Overview) for normalization. Example: In the example below, we prepare a question + context pair for the LayoutLM model. It will give us a prediction of what it thinks the answer is (the span of the answer within the texts parsed from the image). ```python >>> 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 ```rgrrr')rqN) ignore_indexrN)rS start_logits end_logitsrrr) rrzsplitrlrzlenrOclamprrrr)rDrSrTrnrUr%rVrrr{rUrrTrr total_loss ignored_indexrW start_lossend_losss rGr`$LayoutLMForQuestionAnswering.forwardsy~-- ))%'   "!*1#)<<r<#: #++B/::< ''+668   &=+D?'')*Q."1"9"9""==%%'(1, - 5 5b 9 (--a0M-33A}EO)//=AM']CH!,@J :H$x/14J+%!!//))   rI)rr`rz)T)NNNNNNNN)rbrcrdrer*r.rrr@r?rrrrrr`rgrhris@rGrxrxps 8.2(,372604263715e ##d*e %e ))D0 e ((4/ e &&- e ((4/e ))D0e ''$.e +,e  - -e e rIrx)rAr]rprxr%r)r)Erfcollections.abcrr@rtorch.nnrrrr r activationsr modeling_layersr modeling_outputsr r rrrrmodeling_utilsrrprocessing_utilsr pytorch_utilsrutilsrrrr utils.genericrutils.output_capturingrconfiguration_layoutlmr get_loggerrbloggerr;r9Modulerrfloatr~rrrrrrrrrrr rr%rAr]rprx__all__rrIrGrse$ AA&!9G&6RR752   H %LLIIh% II% <<% % << % LL4' %  %%.3)BII3)n   . 299  RYY .D bii 4 RYY  bii$ ryy "!"))!ioii&p +p p fp 1p p f v (?v  v rb %<b b Jy #:y y x rI