\955r>/S?Qr?g)AzPyTorch LayoutLM model.)CallableOptionalUnionN)nn)BCEWithLogitsLossCrossEntropyLossMSELoss)ACT2FN)GradientCheckpointingLayer)BaseModelOutputBaseModelOutputWithPoolingMaskedLMOutputQuestionAnsweringModelOutputSequenceClassifierOutputTokenClassifierOutput)ALL_ATTENTION_FUNCTIONSPreTrainedModel)apply_chunking_to_forward find_pruneable_heads_and_indicesprune_linear_layer)auto_docstringcan_return_tuplelogging)LayoutLMConfigc@^\rSrSrSrU4SjrSSjrSrU=r$)LayoutLMEmbeddings.zGConstruct 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_ids)rF) 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 f/var/www/html/shao/venv/lib/python3.13/site-packages/transformers/models/layoutlm/modeling_layoutlm.pyr(LayoutLMEmbeddings.__init__1s[ !||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%rdtypedevicerr z:The `bbox`coordinate values should be within 0-1000 range.)sizerKr$r>zeroslongr-r/r1r2 IndexErrorr3r4r6r9r<)rB input_idsbboxtoken_type_idsr$ inputs_embeds input_shape seq_lengthrKwords_embeddingsr/left_position_embeddingsupper_position_embeddingsright_position_embeddingslower_position_embeddingser3r4r6 embeddingss rEforwardLayoutLMEmbeddings.forwardBs1  #..*K',,.s3K ^ %.%:!! @T@T  ,,Q  ^ J ! "& '( ((  ( (  ( $  $$ $$ $ ^^J/ \\*- ) bYZ`a a bs/A,F:: G GG) r9r<r3r/r6r4r-r1r2)NNNNN) __name__ __module__ __qualname____firstlineno____doc__r(r^__static_attributes__ __classcell__rDs@rErr.s&Q &  55rGrmodulequerykeyvalueattention_maskscalingr< head_maskc [R"XRSS55U-n Ub"USS2SS2SS2SURS24n X-n [R R U S[RS9RUR5n [R RXURS9n UbXRSSSS5-n [R"X5n U RSS5R5n X4$)NrLr r%)dimrJ)ptrainingr)r>matmul transposeshaper functionalsoftmaxfloat32torJr<rsview contiguous) rhrirjrkrlrmr<rnkwargs attn_weights causal_mask attn_outputs rEeager_attention_forwardr{s<<}}Q':;gEL!$Q1o " o%=> #1 ==((2U]](SVVW\WbWbcL==((6??([L#nnQAq&AA ,,|3K''1-88:K  $$rGc ^\rSrSrU4SjrS S\R S\\RS\\RS\\ S\ \R 4 Sjjr 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 ValueErrorrCintattention_head_size all_head_sizerLinearrirjrkr:attention_probs_dropout_probr<attention_dropoutrmrAs rEr(LayoutLMSelfAttention.__init__sD     : : :a ?PVXhHiHi#F$6$6#78 445Q8   #)#=#= #&v'9'9FTensorr FloatTensorbooltupler^rerfrgs@rErrst607;15,1 !||!!!2!23!E--. ! $D> ! u|| !!rGrcz^\rSrSrU4SjrS\R S\R S\R 4SjrSrU=r $)LayoutLMSelfOutputc(>[TU]5 [R"URUR5Ul[R "URURS9Ul[R"UR5Ul gNr") r'r(rrr+denser9r8r:r;r<rAs rEr(LayoutLMSelfOutput.__init__s` YYv1163E3EF f&8&8f>S>STzz&"<"<= rGr input_tensorrcpURU5nURU5nURX-5nU$Nrr<r9rBrrs rEr^LayoutLMSelfOutput.forward5 =1  ]3 }'CD rGr9rr< r`rarbrcr(r>rr^rerfrgs@rErr6> U\\RWR^R^rGrc ^\rSrSrU4SjrSrS S\RS\\RS\\RS\\ S\ \R4 S jjr S r U=r$) LayoutLMAttentionc>[TU]5 [U5Ul[ U5Ul[ 5Ulgr)r'r(rrBroutputset pruned_headsrAs rEr(LayoutLMAttention.__init__s0 )&1 (0 ErGc6[U5S:Xag[XRRURRUR 5up[ URRU5URl[ URRU5URl[ URRU5URl [ URRUSS9URl URR[U5- URlURRURR-URl UR RU5Ulg)Nrrrq)lenrrBrrrrrirjrkrrrunion)rBheadsindexs rE prune_headsLayoutLMAttention.prune_headss  u:? 7 9900$))2O2OQUQbQb  -TYY__eD *499==%@ ,TYY__eD .t{{/@/@%QO )- (E(EE (R %"&))"?"?$))B_B_"_  --33E:rGrrlrnrrc pUR"U4UUUS.UD6nURUSU5nU4USS-nU$N)rlrnrrr)rBr) rBrrlrnrr} self_outputsattention_outputrs rEr^LayoutLMAttention.forwards]yy  )/     ;;|A F#% QR(88rG)rrrBr)r`rarbrcr(rr>rrrrrr^rerfrgs@rErrsy" ;*7;15,1 ||!!2!23E--.  $D>  u|| rGrcb^\rSrSrU4SjrS\R S\R 4SjrSrU=r $)LayoutLMIntermediateic>[TU]5 [R"URUR 5Ul[UR[5(a[URUl gURUl gr) r'r(rrr+intermediate_sizer isinstance hidden_actstrr intermediate_act_fnrAs rEr(LayoutLMIntermediate.__init__s` YYv1163K3KL f'' - -'-f.?.?'@D $'-'8'8D $rGrrcJURU5nURU5nU$rrrrBrs rEr^LayoutLMIntermediate.forwards& =1 00? rGrrrgs@rErrs(9U\\ellrGrcz^\rSrSrU4SjrS\R S\R S\R 4SjrSrU=r $)LayoutLMOutputic(>[TU]5 [R"URUR 5Ul[R"UR URS9Ul[R"UR5Ul gr) r'r(rrrr+rr9r8r:r;r<rAs rEr(LayoutLMOutput.__init__ s` YYv779K9KL f&8&8f>S>STzz&"<"<= rGrrrcpURU5nURU5nURX-5nU$rrrs rEr^LayoutLMOutput.forward&rrGrrrgs@rErrrrGrc ^\rSrSrU4SjrS S\R S\\RS\\RS\\ S\ \R 4 Sjjr S r S r U=r$) LayoutLMLayeri.c>[TU]5 URUlSUl[ U5Ul[ U5Ul[U5Ul g)Nr) r'r(chunk_size_feed_forward seq_len_dimr attentionr intermediaterrrAs rEr(LayoutLMLayer.__init__/sI '-'E'E$*6208$V, rGrrlrnrrc UR"U4UUUS.UD6nUSnUSSn[URURURU5n U 4U-nU$r)rrfeed_forward_chunkrr) rBrrlrnrr}self_attention_outputsrr layer_outputs rEr^LayoutLMLayer.forward7s"& " )/ "  " 2!4(,0  # #T%A%A4CSCSUe  /G+rGcJURU5nURX!5nU$r)rr)rBrintermediate_outputrs rEr LayoutLMLayer.feed_forward_chunkPs)"//0@A{{#6I rG)rrrrrr)r`rarbrcr(r>rrrrrr^rrerfrgs@rErr.sy-7;15,1 ||!!2!23E--.  $D>  u|| 2rGrc^\rSrSrU4Sjr\S S\RS\\RS\\RS\\ S\\ S\\ S \ \ \R\ 44S jj5rS rU=r$) LayoutLMEncoderiWc>[TU]5 Xl[R"[ UR 5Vs/sHn[U5PM sn5UlSUl gs snf)NF) r'r(rCr ModuleListrangenum_hidden_layersrlayergradient_checkpointing)rBrCirDs rEr(LayoutLMEncoder.__init__XsR  ]]5IaIaCb#cCbaM&$9Cb#cd &+#$dsA%rrlrnroutput_hidden_states return_dictrc U(aSOSnU(aSOSn [UR5H=upU(aX4-nUbX:OSn U "SUUU US.UD6n U SnU(dM5XS4-n M? U(aX4-n[UUU S9$)N)rrlrnrrr)last_hidden_stater attentions) enumeraterr )rBrrlrnrrrr}all_hidden_statesall_self_attentionsr layer_modulelayer_head_mask layer_outputss rEr^LayoutLMEncoder.forward^s#7BD$5b4(4OA#$58H$H!.7.CilO(+-)"3   M*!,M  &91=Mrrrrrrr r^rerfrgs@rErrWs, 7;15,1/4&*& ||& !!2!23& E--. & $D> & 'tn & d^&  uU\\"O3 4& & rGrcb^\rSrSrU4SjrS\R S\R 4SjrSrU=r $)LayoutLMPooleric>[TU]5 [R"URUR5Ul[R "5Ulgr)r'r(rrr+rTanh activationrAs rEr(LayoutLMPooler.__init__s9 YYv1163E3EF '')rGrrc\USS2S4nURU5nURU5nU$)Nr)rr )rBrfirst_token_tensor pooled_outputs rEr^LayoutLMPooler.forwards6+1a40 #56  6 rG)r rrrgs@rErrs($ U\\ellrGrcb^\rSrSrU4SjrS\R S\R 4SjrSrU=r $)LayoutLMPredictionHeadTransformicp>[TU]5 [R"URUR5Ul[ UR[5(a[URUl OURUl [R"URURS9Ul gr) r'r(rrr+rrrrr transform_act_fnr9r8rAs rEr((LayoutLMPredictionHeadTransform.__init__s~ YYv1163E3EF f'' - -$*6+<+<$=D !$*$5$5D !f&8&8f>S>STrGrrclURU5nURU5nURU5nU$r)rrr9rs rEr^'LayoutLMPredictionHeadTransform.forwards4 =1 --m< }5 rG)r9rrrrgs@rErrs)UU\\ellrGrc4^\rSrSrU4SjrSrSrSrU=r$)LayoutLMLMPredictionHeadicH>[TU]5 [U5Ul[R "UR URSS9Ul[R"[R"UR55Ul URURl g)NF)bias) r'r(r transformrrr+r*decoder Parameterr>rNrrAs rEr(!LayoutLMLMPredictionHead.__init__sm 8@yy!3!3V5F5FUS LLV->->!?@ !II rGc:URURlgr)rrrBs rE _tie_weights%LayoutLMLMPredictionHead._tie_weightss II rGcJURU5nURU5nU$r)rrrs rEr^ LayoutLMLMPredictionHead.forwards$}5  ]3 rG)rrr) r`rarbrcr(r!r^rerfrgs@rErrs &&rGrcb^\rSrSrU4SjrS\R S\R 4SjrSrU=r $)LayoutLMOnlyMLMHeadicB>[TU]5 [U5Ulgr)r'r(r predictionsrAs rEr(LayoutLMOnlyMLMHead.__init__s 3F;rGsequence_outputrc(URU5nU$rr()rBr*prediction_scoress rEr^LayoutLMOnlyMLMHead.forwards ,,_=  rGr,rrgs@rEr&r&s(<!u||! !!rGr&c.\rSrSr%\\S'SrSrSrSr g)LayoutLMPreTrainedModelirClayoutlmTcx[U[R5(akURRR SUR RS9 URb%URRR5 gg[U[R5(axURRR SUR RS9 URb2URRURR5 gg[U[5(aJURRR5 URRRS5 g[U[5(a%URRR5 gg)zInitialize the weightsr)meanstdN?)rrrweightdatanormal_rCinitializer_rangerzero_r)r!r7fill_r)rBrhs rE _init_weights%LayoutLMPreTrainedModel._init_weightss0 fbii ( ( MM   & &CT[[5R5R & S{{&   &&('  - - MM   & &CT[[5R5R & S!!- ""6#5#56<<>.  1 2 2 KK   " " $ MM   $ $S )  8 9 9 KK   " " $:rGrN) r`rarbrcr__annotations__base_model_prefixsupports_gradient_checkpointingr<rerrGrEr0r0s "&*#%rGr0cn^\rSrSrU4SjrSrSrSr\\ SS\ \ RS\ \ RS\ \ RS \ \ RS \ \ RS \ \ RS \ \ RS \ \S\ \S\ \S\\\44Sjj55rSrU=r$) LayoutLMModelic>[TU]U5 Xl[U5Ul[ U5Ul[U5UlUR5 gr) r'r(rCrr]rencoderrpooler post_initrAs rEr(LayoutLMModel.__init__sE   ,V4&v. $V,  rGc.URR$rr]r-r s rEget_input_embeddings"LayoutLMModel.get_input_embeddingss...rGc$XRlgrrI)rBrks rEset_input_embeddings"LayoutLMModel.set_input_embeddingss */'rGcUR5H7up#URRURR U5 M9 g)z Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base class PreTrainedModel N)itemsrDrrr)rBheads_to_prunerrs rE _prune_headsLayoutLMModel._prune_headss< +002LE LL  u % / / ; ;E B3rGrQrRrlrSr$rnrTrrrrc UbUOURRnU bU OURRn U bU OURRn UbUb [ S5eUb"UR X5 UR 5n O"UbUR 5SSn O [ S5eUb URO URn Uc[R"XS9nUc$[R"U [RU S9nUc'[R"U S-[RU S9nURS5RS 5n U RURS 9n S U - [R"UR5R -n UbUR#5S:XahURS 5RS 5RS5RS5nUR%URR&SSSS5nOCUR#5S :Xa/URS5RS5RS5nUR[)UR+55RS 9nOS/URR&-nUR-UUUUUS 9nUR/UU UUU SS9nUS nUR1U5n[3UUUR4UR6S9$)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)rKrI)rrL)rJr5r)rQrRr$rSrTT)rnrrr)r pooler_outputrr)rCrruse_return_dictr%warn_if_padding_and_no_attention_maskrMrKr>onesrNrO unsqueezerzrJfinfominrqr@rnext parametersr]rDrErrr)rBrQrRrlrSr$rnrTrrrrUrKextended_attention_maskembedding_outputencoder_outputsr*rs rEr^LayoutLMModel.forwardsj2C1N-TXT_T_TqTq$8$D $++JjJj &1%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_"_  }}!#%//2<!>>I??%)' + ,,  #/!5 ' *!, O4 )-')77&11   rG)rCr]rDrE) NNNNNNNNNN)r`rarbrcr(rJrMrRrrrr> LongTensorrrrrrr^rerfrgs@rErBrBs1 /0C15+/6:59371559,0/3&*s E,,-s u''(s !!2!23 s !!1!12 s u//0 s E--.s   1 12s $D>s 'tns d^s  u00 1s s rGrBc^\rSrSrSS/rU4SjrSrSrSr\ \ SS\ \ RS \ \ RS \ \ RS \ \ RS \ \ RS \ \ RS\ \ RS\ \ RS\ \S\ \S\ \S\\\44Sjj55rSrU=r$)LayoutLMForMaskedLMiyzcls.predictions.decoder.biaszcls.predictions.decoder.weightc>[TU]U5 [U5Ul[ U5UlUR 5 gr)r'r(rBr1r&clsrFrAs rEr(LayoutLMForMaskedLM.__init__}s4  %f- &v. rGcBURRR$rr1r]r-r s rErJ(LayoutLMForMaskedLM.get_input_embeddings}}''777rGcBURRR$r)rgr(rr s rEget_output_embeddings)LayoutLMForMaskedLM.get_output_embeddingssxx##+++rGcXRRlURURRlgr)rgr(rr)rBnew_embeddingss rEset_output_embeddings)LayoutLMForMaskedLM.set_output_embeddingss*'5$$2$7$7!rGrQrRrlrSr$rnrTlabelsrrrrc jU bU OURRn URUUUUUUUU U SS9 n U Sn URU 5nSnUbF[ 5nU"UR SURR 5UR S55n[UUU 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 ```NT)rlrSr$rnrTrrrrr%losslogitsrr) rCrWr1rgrr{r*rrr)rBrQrRrlrSr$rnrTrtrrrrr*r-masked_lm_lossloss_fcts rEr^LayoutLMForMaskedLM.forwards@&1%rcrrrrrr^rerfrgs@rErereysT8:Z[8,815+/6:59371559-1,0/3&*] E,,-] u''(] !!2!23 ] !!1!12 ] u//0 ] E--.]   1 12] ))*] $D>] 'tn] d^]  un$ %] ] rGrez 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_introc^\rSrSrU4SjrSr\\SS\\ RS\\ RS\\ RS\\ RS\\ RS \\ RS \\ RS \\ RS \\ S \\ S\\ S\ \\44Sjj55rSrU=r$)!LayoutLMForSequenceClassificationic0>[TU]U5 URUl[U5Ul[ R "UR5Ul[ R"URUR5Ul UR5 gr r'r( num_labelsrBr1rr:r;r<rr+ classifierrFrAs rEr(*LayoutLMForSequenceClassification.__init__i   ++%f- zz&"<"<= ))F$6$68I8IJ rGcBURRR$rrjr s rErJ6LayoutLMForSequenceClassification.get_input_embeddingsrlrGrQrRrlrSr$rnrTrtrrrrc U bU OURRn URUUUUUUUU U SS9 n U Sn URU 5n UR U 5nSnUGbURR cUR S:XaSURlOoUR S:aNUR[R:XdUR[R:XaSURlOSURlURR S:XaI[5nUR S:Xa&U"UR5UR55nOU"X5nOURR S:Xa=[5nU"URSUR 5URS55nO,URR S:Xa[5nU"X5n[!UUU R"U R$S 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. 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 ```NT rQrRrlrSr$rnrTrrrr regressionsingle_label_classificationmulti_label_classificationr%rv)rCrWr1r<r problem_typerrJr>rOrr squeezerr{rrrr)rBrQrRrlrSr$rnrTrtrrrrrrxrwrzs rEr^)LayoutLMForSequenceClassification.forwards@&1%rcrrrrrr^rerfrgs@rErrs?815+/6:59371559-1,0/3&*n E,,-n u''(n !!2!23 n !!1!12 n u//0 n E--.n   1 12n ))*n $D>n 'tnn d^n  u.. /n n rGra3 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. c^\rSrSrU4SjrSr\\SS\\ RS\\ RS\\ RS\\ RS\\ RS \\ RS \\ RS \\ RS \\ S \\ S\\ S\ \\44Sjj55rSrU=r$)LayoutLMForTokenClassificationiyc0>[TU]U5 URUl[U5Ul[ R "UR5Ul[ R"URUR5Ul UR5 grrrAs rEr('LayoutLMForTokenClassification.__init__rrGcBURRR$rrjr s rErJ3LayoutLMForTokenClassification.get_input_embeddingsrlrGrQrRrlrSr$rnrTrtrrrrc xU bU OURRn URUUUUUUUU U SS9 n U Sn URU 5n UR U 5nSnUb<[ 5nU"UR SUR5UR S55n[UUU 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 ```NTrrr%rv) rCrWr1r<rrr{rrrr)rBrQrRrlrSr$rnrTrtrrrrr*rxrwrzs rEr^&LayoutLMForTokenClassification.forwards|&1%rcrrrrrr^rerfrgs@rErrys?815+/6:59371559-1,0/3&*Z E,,-Z u''(Z !!2!23 Z !!1!12 Z u//0 Z E--.Z   1 12Z ))*Z $D>Z 'tnZ d^Z  u++ ,Z Z rGrc^\rSrSrSU4SjjrSr\\SS\\ RS\\ RS\\ RS\\ RS\\ RS \\ RS \\ RS \\ RS \\ RS \\ S\\ S\\ S\ \\44Sjj55rSrU=r$)LayoutLMForQuestionAnsweringic>[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(rrBr1rrr+ qa_outputsrF)rBrChas_visual_segment_embeddingrDs rEr(%LayoutLMForQuestionAnswering.__init__sU   ++%f- ))F$6$68I8IJ rGcBURRR$rrjr s rErJ1LayoutLMForQuestionAnswering.get_input_embeddingsrlrGrQrRrlrSr$rnrTstart_positions end_positionsrrrrc U bU OURRn URUUUUUUUU U SS9 n U SnURU5nUR SSS9unnUR S5R 5nUR S5R 5nSnUbU b[UR55S:aUR S5n[U R55S:aU R S5n URS5nURSU5nU RSU5n [US9nU"UU5nU"UU 5nUU-S - n[UUUU 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 ```NTrrrr%r) ignore_indexrL)rw start_logits end_logitsrr)rCrWr1rsplitrr|rrMclamprrrr)rBrQrRrlrSr$rnrTrrrrrrr*rxrr total_loss ignored_indexrz start_lossend_losss rEr^$LayoutLMForQuestionAnswering.forwardsD&1%rcrrrrrr^rerfrgs@rErrsX 815+/6:593715596:48,0/3&*m E,,-m u''(m !!2!23 m !!1!12 m u//0 m E--.m   1 12m "%"2"23m   0 01m $D>m 'tnm d^m  u22 3m m rGr)rerrrrBr0)rN)@rdtypingrrrr>torch.utils.checkpointrtorch.nnrrr activationsr modeling_layersr modeling_outputsr rrrrrmodeling_utilsrr pytorch_utilsrrrutilsrrrconfiguration_layoutlmr get_loggerr`loggerr9r7Modulerrfloatrrrrrrrrrrrr&r0rBrerrr__all__rrGrErsw,, AA!9Gll>>2   H %LLIIh(,% II% <<% % << % U\\* %  %% %%87BII7v  * *\ 299  RYY %.%R. bii. d RYY  bii$ryy0!"))!%o%%0O +O O du 1u u p ~ (?~  ~ Bj %<j j ZA #:A A H rG