`i>jdZddlZddlZddlmZmZddlZddlmZddl mcm Z ddlm Z m Z mZddlmZddlmZddlmZmZmZmZdd lmZdd lmZdd lmZmZmZd d l m!Z!ej"e#Z$Gddej%Z&Gddej%Z'eGddeZ(Gddej%Z)Gddej%Z*Gddej%Z+GddeZ,Gddej%Z-Gddej%Z.Gd d!ej%Z/eGd"d#e(Z0Gd$d%ej%Z1ed&'Gd(d)e(Z2eGd*d+e(Z3ed,'Gd-d.e(Z4gd/Z5dS)0zPyTorch LayoutLMv3 model.N)OptionalUnion)BCEWithLogitsLossCrossEntropyLossMSELoss)ACT2FN)GradientCheckpointingLayer)BaseModelOutputQuestionAnsweringModelOutputSequenceClassifierOutputTokenClassifierOutput)PreTrainedModel)apply_chunking_to_forward)auto_docstringlogging torch_int)LayoutLMv3Configc*eZdZdZfdZddZxZS)LayoutLMv3PatchEmbeddingszLayoutLMv3 image (patch) embeddings. This class also automatically interpolates the position embeddings for varying image sizes.ctt|jtjjr|jn |j|jf}t|jtjjr|jn |j|jf}|d|dz|d|dzf|_tj |j |j |||_ dS)Nrr) kernel_sizestride)super__init__ isinstance input_size collectionsabcIterable patch_size patch_shapennConv2d num_channels hidden_sizeproj)selfconfig image_sizer" __class__s /home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/transformers/models/layoutlmv3/modeling_layoutlmv3.pyrz"LayoutLMv3PatchEmbeddings.__init__3s &+[_-EFF 8F  #V%67 &+[_-EFF 8F  #V%67  'qMZ]:JqMZXY]STTTz&"<==   EL)GHHOOPWXXej    ".#%<  *F,>DL\$ $ $  &(\&2SU[Uk%l%l"%'\&2SU[Uk%l%l"%'\&2SU[Uf%g%g"%'\&2SU[Uf%g%g"""r.c  ||dddddf}||dddddf}||dddddf}||dddddf}n"#t$r}td|d}~wwxYw|t j|dddddf|dddddfz dd}|t j|dddddf|dddddfz dd}t j||||||gd} | S) Nrrr1rz;The `bbox` coordinate values should be within 0-1000 range.ir0dim)rerf IndexErrorrhr^clipricat) r)bboxleft_position_embeddingsupper_position_embeddingsright_position_embeddingslower_position_embeddingserhrispatial_position_embeddingss r-%calculate_spatial_position_embeddingsz>LayoutLMv3TextEmbeddings.calculate_spatial_position_embeddingsns c'+'A'A$qqq!!!Qw-'P'P $(,(B(B4111a=(Q(Q %(,(B(B4111a=(Q(Q %(,(B(B4111a=(Q(Q % % c c cZ[[ab b c!% : :5:d111aaaQR7mVZ[\[\[\^_^_^_ab[bVcFcefhl;m;m n n $ : :5:d111aaaQR7mVZ[\[\[\^_^_^_ab[bVcFcefhl;m;m n n',i()))%%   ' ' ' #+*sBB B*B%%B*c||}tj|d||z}||zS)z Replace non-padding symbols with their position numbers. Position numbers begin at padding_idx+1. Padding symbols are ignored. This is modified from fairseq's `utils.make_positions`. rrl)neintr^cumsumtype_aslong)r) input_idsrMmaskincremental_indicess r-"create_position_ids_from_input_idsz;LayoutLMv3TextEmbeddings.create_position_ids_from_input_idss` ||K((,,..$|Da888@@FF$N"''))K77r.c|dd}|d}tj|jdz||jzdztj|j}|d|S)z We are provided embeddings directly. We cannot infer which are padded so just generate sequential position ids. Nr0rdtypedevicer)r3r^r_rMr~r unsqueezera)r) inputs_embeds input_shapesequence_lengthrPs r-&create_position_ids_from_inputs_embedsz?LayoutLMv3TextEmbeddings.create_position_ids_from_inputs_embedss$((**3B3/ %a.|  q /D4D"Dq"HPUPZcpcw   %%a((// <<rbrws r-rAz LayoutLMv3TextEmbeddings.forwardsJ  $#FFyRVRbccff$    $JJ=YY  #..**KK',,..ss3K  !"[EJtO`OghhhN   00;;M $ : :> J J"%:: "66|DD)) &*&P&PQU&V&V#"== ^^J// \\*-- r.)NNNNN) rDrErFrGrrxrrrArHrIs@r-rKrKRshhhhh.+++4888 = = =  ''''''''r.rKc$eZdZUeed<dZdZdS)LayoutLMv3PreTrainedModelr* layoutlmv3c`t|tjtjfrT|jjd|jj|j |j j dSdSt|tj r_|jjd|jj|j +|jj|j  dSdSt|tj r?|j j |jjddSt|trJ|jjr@|jj |jj dSdSdS)zInitialize the weights)meanstdNg?)rr$Linearr%weightdatanormal_r*initializer_rangebiaszero_rRrMrXfill_LayoutLMv3Model visual_embed cls_token pos_embed)r)modules r- _init_weightsz'LayoutLMv3PreTrainedModel._init_weightss fry")4 5 5 . M  & &CT[5R & S S S{&  &&((((('&  - - . M  & &CT[5R & S S S!- "6#56<<>>>>>.-  - - . K  " " $ $ $ M  $ $S ) ) ) ) )  0 0 .{' . %++--- %++----- . . . .r.N)rDrErFr__annotations__base_model_prefixrr.r-rrs7 $.....r.rc8eZdZfdZddZ ddZxZS) LayoutLMv3SelfAttentionct|j|jzdkr0t |ds t d|jd|jd|j|_t |j|jz |_|j|jz|_tj |j|j|_ tj |j|j|_ tj |j|j|_ tj|j|_|j|_|j|_dS)Nrembedding_sizezThe hidden size (z6) is not a multiple of the number of attention heads ())rrr'num_attention_headshasattr ValueErrorr{attention_head_size all_head_sizer$rquerykeyvaluerZattention_probs_dropout_probr\has_relative_attention_biashas_spatial_attention_biasrjs r-rz LayoutLMv3SelfAttention.__init__s1    : :a ? ?PVXhHiHi ?8F$688 4888  $*#= #&v'9FS"S* *,CD 6G]=/22mM]r.)rNNFNN)rDrErFrrrArHrIs@r-rrsvLLLLL( 8 8 8 8<<<<<<<<r.rcPeZdZfdZdejdejdejfdZxZS)LayoutLMv3SelfOutputcttj|j|j|_tj|j|j|_tj|j |_ dSNrN) rrr$rr'denserXrYrZr[r\rjs r-rzLayoutLMv3SelfOutput.__init__Dsf Yv163EFF f&8f>STTTz&"<== r.r input_tensorreturnc||}||}|||z}|SrBrr\rXr)rrs r-rAzLayoutLMv3SelfOutput.forwardJ@ =11  ]33 }|'CDD r.rDrErFrr^TensorrArHrIs@r-rrCi>>>>> U\RWR^r.rc0eZdZfdZ ddZxZS)LayoutLMv3Attentionctt||_t ||_dSrB)rrrr)routputrjs r-rzLayoutLMv3Attention.__init__Ss; +F33 *622 r.NFc|||||||}||d|}|f|ddz} | S)Nrrrr)r)r) r)rrrrrr self_outputsattention_outputrs r-rAzLayoutLMv3Attention.forwardXscyy    ! !   ;;|A FF#% QRR(88r.r)rDrErFrrArHrIs@r-rrRs]33333r.rc6eZdZfdZ ddZdZxZS)LayoutLMv3Layerct|j|_d|_t ||_t ||_t||_ dSNr) rrchunk_size_feed_forward seq_len_dimr attentionLayoutLMv3Intermediate intermediateLayoutLMv3Outputrrjs r-rzLayoutLMv3Layer.__init__ps^ '-'E$,V4426::&v.. r.NFc|||||||}|d}|dd} t|j|j|j|} | f| z} | S)N)rrrrr)rrfeed_forward_chunkrr) r)rrrrrrself_attention_outputsrr layer_outputs r-rAzLayoutLMv3Layer.forwardxs"&   /! "0" " 2!4(,0  #T%A4CSUe   /G+r.c\||}|||}|SrB)rr)r)rintermediate_outputrs r-rz"LayoutLMv3Layer.feed_forward_chunks2"//0@AA{{#68HII r.r)rDrErFrrArrHrIs@r-rrosl/////8r.rcLeZdZfdZd dZdZdZ d d ZxZS) LayoutLMv3Encodercht|_tjfdt jD|_d|_j |_ j |_ |j r>j |_ j |_ tj |j jd|_|j rfj|_j|_tj |jjd|_tj |jjd|_dSdS)Nc.g|]}tSr)r).0rr*s r- z.LayoutLMv3Encoder.__init__..s!#e#e#eOF$;$;#e#e#er.F)r)rrr*r$ ModuleListrangenum_hidden_layerslayergradient_checkpointingrr rel_pos_bins max_rel_posrr rel_pos_biasmax_rel_2d_posrel_2d_pos_binsrel_pos_x_biasrel_pos_y_biasrjs `r-rzLayoutLMv3Encoder.__init__s&  ]#e#e#e#eU6KcEdEd#e#e#eff &+#+1+M(*0*K'  + e & 3D %1D  " $*;V=W^c d d dD   * j"("7D #)#9D "$)D,@&B\ch"i"i"iD "$)D,@&B\ch"i"i"iD     j jr.Trc:d}|r8|dz}||dk|zz }tj|}n(tj| tj|}|dz}||k}|tj||z tj||z z ||z ztjz} tj | tj | |dz } |tj ||| z }|S)Nrr1r) r~r^absmax zeros_likelogfloatrrmin full_likewhere) r)relative_position bidirectional num_buckets max_distanceretn max_exactis_small val_if_larges r-relative_position_bucketz*LayoutLMv3Encoder.relative_position_buckets  S A K %)//11K? ?C +,,AA ,,e.>?P.Q.QRRA 1$ y=! Iaggii)+ , ,tx y8P/Q/Q QU`clUl m "UZ.. yu|[[\_/]/]^^  u{8Q 555 r.c|d|dz }|||j|j}t j5|jj| dddd}dddn #1swxYwY| }|S)Nrr0rrrrrr1) rr$r r r^no_gradr rtr6r)r)rP rel_pos_matrs r-_cal_1d_pos_embz!LayoutLMv3Encoder._cal_1d_pos_embs ",,R00<3I3I"3M3MM // ))0  ]__ P P'.00227;CCAq!QOOG P P P P P P P P P P P P P P P$$&&s!;B((B,/B,c|dddddf}|dddddf}|d|dz }|d|dz }|||j|j}|||j|j}t j5|jj| dddd}|j j| dddd}dddn #1swxYwY| }| }||z}|S)Nrrrr0r&rr1) rr$rr r^r'rrr(r6rr) r)rqposition_coord_xposition_coord_yrel_pos_x_2d_matrel_pos_y_2d_mat rel_pos_x rel_pos_yrs r-_cal_2d_pos_embz!LayoutLMv3Encoder._cal_2d_pos_embs111a=111a=+55b99z,LayoutLMv3Encoder.forward..s4 =  !===r.last_hidden_stater attentions)rr*rr2 enumeratertupler )r)rrqrrroutput_hidden_states return_dictrPr?r@all_hidden_statesall_self_attentionsrri layer_modulelayer_head_mask layer_outputss r-rAzLayoutLMv3Encoder.forwardsy#7@BBD$5?bb48<8Xb$&&|444^b373R\T))$///X\ (44 P POA|# I$58H$H!.7.CillO(L!% M*!,M  P&9]1=Msf Yv79KLL f&8f>STTTz&"<== r.rrrc||}||}|||z}|SrBrrs r-rAzLayoutLMv3Output.forwardDrr.rrIs@r-rr=rr.rceZdZfdZdZdZdZddZdZd Z e dd e e j d e e j d e e jde e j de e j de e jde e jde e jde ede ede edeeeffdZxZS)rc|t|||_|jrt ||_|jrGt||_t|j |j z }tj tjdd|j|_tj tjd||zdz|j|_tjd|_tj|j|j|_tj|j|_|jjs |jjr|||ftj|jd|_t;||_|dS)Nrr)prN)r+gư>) rrr* text_embedrKr>rr patch_embedr{rr"r$ Parameterr^rr'rrrZpos_droprXrYr[r\rrinit_visual_bboxnormrencoder init_weights)r)r*r3r,s r-rzLayoutLMv3Model.__init__Msv       ?6v>>DO   C 9@@D v(6+<<==D\%+aF>> V%7TBBBDI(00  r.c|jjSrBr>rU)r)s r-get_input_embeddingsz$LayoutLMv3Model.get_input_embeddingsjs ..r.c||j_dSrBrZ)r)rs r-set_input_embeddingsz$LayoutLMv3Model.set_input_embeddingsms*/'''r.c|D]/\}}|jj|j|0dS)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)itemsrWrr prune_heads)r)heads_to_prunerheadss r- _prune_headszLayoutLMv3Model._prune_headspsU +0022 C CLE5 L u % / ; ;E B B B B C Cr.rec .tjtjd||ddzz||dd}tjtjd||ddzz||dd}tj|dd|dd|dd|dddd|dd|dd|dd|ddddgddd}tjdd|dz |dz gg}tj||gd|_ dS) zJ Create the bounding boxes for the visual (patch) tokens. rrtrunc) rounding_modeNr0rl) r^divr_stackrepeatr;r5tensorrp visual_bbox)r)r+max_len visual_bbox_x visual_bbox_yro cls_token_boxs r-rUz LayoutLMv3Model.init_visual_bboxxs LGz!}q'897 C CZPQ]bi    LGz!}q'897 C CZPQ]bi   kcrc"))*Q-;;crc"))*Q-;;EEaKKabb!((A::abb!((A::DDQJJ       $r1++  ueWq['A+&N%OPP  9m[%AqIIIr.c|j|dd}|||}|Sr)rormrtype)r)rrrros r-calculate_visual_bboxz%LayoutLMv3Model.calculate_visual_bboxsA&--j!Q?? !nnV,,11%88 r.c>||}|\}}}|j|dd}t j||fd}|j ||jz}||}||}|S)Nr0rrl) rRr3rrar^rprrTrV)r)r<r>rseq_lenr cls_tokenss r- forward_imagezLayoutLMv3Model.forward_images%%l33 ",!2!2 GQ^**:r2>> Y J7Q???  > %#dn4J]]:.. YYz** r.NrrqrrrPrrr<rr<r=rc | | n |jj} | | n |jj} | | n |jj} |!|} | \} }|j}nS|)|dd} | \} }|j}n(|t |} |j}ntd|||tj | |f|}|!tj | tj |}|?tj tt| dgztj |}||||||}dx}}dx}}|t|jd|jjz t|jd |jjz }}||}tj | |jd ftj |}|tj||gd }n|}|jjs |jjr|jjr?||tj | }|tj||gd }n|}tjd |jd tj || d }||^tjd | d |d }|| }tj||gd }n|}||tj||gd }n|}||}||}ng|jjs |jjrO|jjr|}|jjr5|jjddd| d f}||}|}||d||j }|!||jj"}|#|||||| | | || }|d }| s|f|d dzStI||j%|j&S)a input_ids (`torch.LongTensor` of shape `(batch_size, token_sequence_length)`): Indices of input sequence tokens in the vocabulary. Note that `sequence_length = token_sequence_length + patch_sequence_length + 1` where `1` is for [CLS] token. See `pixel_values` for `patch_sequence_length`. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input IDs?](../glossary#input-ids) bbox (`torch.LongTensor` of shape `(batch_size, token_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. Note that `sequence_length = token_sequence_length + patch_sequence_length + 1` where `1` is for [CLS] token. See `pixel_values` for `patch_sequence_length`. token_type_ids (`torch.LongTensor` of shape `(batch_size, token_sequence_length)`, *optional*): Segment token indices to indicate first and second portions of the inputs. Indices are selected in `[0, 1]`: - 0 corresponds to a *sentence A* token, - 1 corresponds to a *sentence B* token. Note that `sequence_length = token_sequence_length + patch_sequence_length + 1` where `1` is for [CLS] token. See `pixel_values` for `patch_sequence_length`. [What are token type IDs?](../glossary#token-type-ids) position_ids (`torch.LongTensor` of shape `(batch_size, token_sequence_length)`, *optional*): Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0, config.max_position_embeddings - 1]`. Note that `sequence_length = token_sequence_length + patch_sequence_length + 1` where `1` is for [CLS] token. See `pixel_values` for `patch_sequence_length`. [What are position IDs?](../glossary#position-ids) inputs_embeds (`torch.FloatTensor` of shape `(batch_size, token_sequence_length, hidden_size)`, *optional*): Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This is useful if you want more control over how to convert *input_ids* indices into associated vectors than the model's internal embedding lookup matrix. Examples: ```python >>> from transformers import AutoProcessor, AutoModel >>> from datasets import load_dataset >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False) >>> model = AutoModel.from_pretrained("microsoft/layoutlmv3-base") >>> 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 ```Nr0zEYou have to specify either input_ids or inputs_embeds or pixel_values)rrrj)rrqrPrrr1rrrl)rrr)r) rqrPrrrr<r=r?r@r7)'r*rr<use_return_dictr3rlenrr^onesrr~r;listr>rr7r"rzrprrrvr_rmrrarXr\rP expand_asget_extended_attention_maskr get_head_maskrrWr rr9)r)rrqrrrPrrr<rr<r=rrrrembedding_output final_bboxfinal_position_idsr?r@visual_embeddingsvisual_attention_maskrovisual_position_idsextended_attention_maskencoder_outputssequence_outputs r-rAzLayoutLMv3Model.forwards\2C1N--TXT_Tq$8$D $+Jj &1%&#Q#Q#Q#[#[\]#^#^L#/#6#6{#C#CL).LBU3V\])^)^)^&&)<&$ (A#(9.>@Q-RXY#Z#Z#Z  #4 #~~.>?? #||,<==   [ 4 2 8^ 2{5 "! {6 2#;AAA?OQ?OC 'tnC d^C  uo% &C C C ^C C C C C r.rc*eZdZdZdfd ZdZxZS)LayoutLMv3ClassificationHeadz\ Head for sentence-level classification tasks. Reference: RobertaClassificationHead Fct||_|r(tj|jdz|j|_n$tj|j|j|_|j|jn|j}tj ||_ tj|j|j |_ dS)Nr) rr pool_featurer$rr'rclassifier_dropoutr[rZr\ num_labelsout_proj)r)r*rrr,s r-rz%LayoutLMv3ClassificationHead.__init__qs (  K6#5#96;MNNDJJ6#5v7IJJDJ)/)B)NF % %TZTn z"455  &"4f6GHH r.c||}||}tj|}||}||}|SrB)r\rr^tanhr)r)xs r-rAz$LayoutLMv3ClassificationHead.forward~sR LLOO JJqMM JqMM LLOO MM!  r.)FrCrIs@r-rrls\ I I I I I Ir.ra LayoutLMv3 Model with a token classification head on top (a linear layer on top of the final hidden states) e.g. for sequence labeling (information extraction) tasks such as [FUNSD](https://guillaumejaume.github.io/FUNSD/), [SROIE](https://rrc.cvc.uab.es/?ch=13), [CORD](https://github.com/clovaai/cord) and [Kleister-NDA](https://github.com/applicaai/kleister-nda). ) custom_introc~eZdZfdZe ddeejdeejdeejdeejdeejdeejd eejd eejd ee d ee d ee deejde e e ffdZ xZS) LayoutLMv3ForTokenClassificationczt||j|_t||_t j|j|_|jdkr%t j |j |j|_ nt|d|_ | dS)N Fr)rrrrrr$rZr[r\rr' classifierrrXrjs r-rz)LayoutLMv3ForTokenClassification.__init__s     +)&11z&"<==  r ! ! i(:F>> from transformers import AutoProcessor, AutoModelForTokenClassification >>> from datasets import load_dataset >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False) >>> model = AutoModelForTokenClassification.from_pretrained("microsoft/layoutlmv3-base", num_labels=7) >>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train") >>> example = dataset[0] >>> image = example["image"] >>> words = example["tokens"] >>> boxes = example["bboxes"] >>> word_labels = example["ner_tags"] >>> encoding = processor(image, words, boxes=boxes, word_labels=word_labels, return_tensors="pt") >>> outputs = model(**encoding) >>> loss = outputs.loss >>> logits = outputs.logits ```N) rqrrrPrrrr<r=r<r0rrlosslogitsrr9) r*r|rr3r\rrr5rrrr9)r)rrqrrrPrrrrr<r=r<rrrrrrloss_fctrs r-rAz(LayoutLMv3ForTokenClassification.forwardsg^&1%V 'tnV d^V u/0V  u++ ,V V V ^V V V V V r.rc eZdZfdZe ddeejdeejdeejdeejdeejdeejd eejd eejd ee d ee d ee deejdeejde e e ffdZ xZS)LayoutLMv3ForQuestionAnsweringct||j|_t||_t |d|_|dSNFr)rrrrrr qa_outputsrXrjs r-rz'LayoutLMv3ForQuestionAnswering.__init__s`     +)&116vERRR r.NrrrrPrrstart_positions end_positionsrr<r=rqr<rc | | n |jj} |||||||| | | | |  }|d}||}|dd\}}|d}|d}d}||t|dkr|d}t|dkr|d}|d}| d|}| d|}t|}|||}|||}||zdz }| s||f|ddz}||f|zn|St||||j |j S) 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. Examples: ```python >>> from transformers import AutoProcessor, AutoModelForQuestionAnswering >>> from datasets import load_dataset >>> import torch >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False) >>> model = AutoModelForQuestionAnswering.from_pretrained("microsoft/layoutlmv3-base") >>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train") >>> example = dataset[0] >>> image = example["image"] >>> question = "what's his name?" >>> words = example["tokens"] >>> boxes = example["bboxes"] >>> encoding = processor(image, question, words, boxes=boxes, return_tensors="pt") >>> start_positions = torch.tensor([1]) >>> end_positions = torch.tensor([3]) >>> outputs = model(**encoding, start_positions=start_positions, end_positions=end_positions) >>> loss = outputs.loss >>> start_scores = outputs.start_logits >>> end_scores = outputs.end_logits ```N rrrPrrrr<r=rqr<rrr0rl) ignore_indexr1)r start_logits end_logitsrr9)r*r|rrsplitsqueezerr}r3clamprr rr9)r)rrrrPrrrrrr<r=rqr<rrrrr total_loss ignored_indexr start_lossend_lossrs r-rAz&LayoutLMv3ForQuestionAnswering.forwardsf&1%d 'tnd d^d u'(d u/0d  u22 3d d d ^d d d d d r.ra  LayoutLMv3 Model with a sequence classification head on top (a linear layer on top of the final hidden state of the [CLS] token) e.g. for document image classification tasks such as the [RVL-CDIP](https://www.cs.cmu.edu/~aharley/rvl-cdip/) dataset. c~eZdZfdZe ddeejdeejdeejdeejdeejdeejd eejd ee d ee d ee d eejdeejde e e ffdZ xZS)#LayoutLMv3ForSequenceClassificationct||j|_||_t ||_t |d|_|dSr) rrrr*rrrrrXrjs r-rz,LayoutLMv3ForSequenceClassification.__init__rsg     + )&116vERRR r.NrrrrPrrrrr<r=rqr<rc | | n |jj} ||||||||| | | |  } | ddddddf}||}d}|Z|jjf|jdkr d|j_nN|jdkr7|jtjks|jtj kr d|j_n d|j_|jjdkrWt}|jdkr1|| | }n|||}n|jjdkrGt}|| d|j| d}n*|jjdkrt}|||}| s|f| ddz}||f|zn|St||| j| j S) 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. Examples: ```python >>> from transformers import AutoProcessor, AutoModelForSequenceClassification >>> from datasets import load_dataset >>> import torch >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv3-base", apply_ocr=False) >>> model = AutoModelForSequenceClassification.from_pretrained("microsoft/layoutlmv3-base") >>> 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") >>> sequence_label = torch.tensor([1]) >>> outputs = model(**encoding, labels=sequence_label) >>> loss = outputs.loss >>> logits = outputs.logits ```Nrrr regressionsingle_label_classificationmulti_label_classificationr0r)r*r|rr problem_typerrr^r~r{rrrr5rr rr9)r)rrrrPrrrrr<r=rqr<rrrrrrs r-rAz+LayoutLMv3ForSequenceClassification.forward{s%\&1%` 'tn` d^` u'(` u/0`  u.. /` ` ` ^` ` ` ` ` r.r)rrrrr)6rGrrtypingrrr^torch.nnr$torch.nn.functional functionalr8rrr activationsr modeling_layersr modeling_outputsr r r rmodeling_utilsr pytorch_utilsrutilsrrrconfiguration_layoutlmv3r get_loggerrDloggerModulerrKrrrrrrrrrrrrr__all__rr.r-rs  """""""" AAAAAAAAAA!!!!!!999999 .-----666666 766666  H % %        Fsssssrysssl........2]]]]]bi]]]B     29   "):(((((0(((VO O O O O  O O O f     RY        ry   ] ] ] ] ] /] ] ] @ 296e e e e e '@e e e Po o o o o %>o o o dk k k k k *Ck k k \   r.