fTh2SrSSKrSSKrSSKJrJrJr SSKrSSKJr SSK J r SSK J r SSK Jr SS KJrJr SS KJrJr SS KJr SS KJrJr S SKJr \R8"\5r"SS\R>5r "SS\R>5r!"SS\RD5r#"SS\RD5r$"SS\RD5r%\"SS\55r&"SS\&5r'\"SS9"SS \&55r(\"S!S9"S"S#\&\55r)S#S/r*g)$z/PyTorch TrOCR decoder model (based on RoBERTa).N)OptionalTupleUnion)nn)CrossEntropyLoss)ACT2FN)GenerationMixin)_prepare_4d_attention_mask!_prepare_4d_causal_attention_mask))BaseModelOutputWithPastAndCrossAttentions!CausalLMOutputWithCrossAttentions)PreTrainedModel)auto_docstringlogging) TrOCRConfigc^\rSrSrSrS\S\4U4SjjrS S\RS\S\R4U4S jjjr S r U=r $) TrOCRLearnedPositionalEmbedding)zF This module learns positional embeddings up to a fixed maximum size. num_embeddings embedding_dimcL>SUl[TU] XR-U5 g)N)offsetsuper__init__)selfrr __class__s `/var/www/auris/envauris/lib/python3.13/site-packages/transformers/models/trocr/modeling_trocr.pyr(TrOCRLearnedPositionalEmbedding.__init__.s"  ++5}E input_idspast_key_values_length position_idsc>Uc]URSSupE[R"X"U-[RURR S9R US5nOURS5n[TU]%X0R-5$)z3`input_ids' shape is expected to be [bsz x seqlen].Nr)dtypedevicer) shapetorcharangelongweightr(expand unsqueezerforwardr)rr#r$r%bszseq_lenrs r r1'TrOCRLearnedPositionalEmbedding.forward4s  $??2A.LC <<&(HPUPZPZcgcncncucufS"o (11!4Lw|kk9::r")rrN) __name__ __module__ __qualname____firstlineno____doc__intrr+Tensorr1__static_attributes__ __classcell__rs@r rr)sHFsF3F ; ;s ;^c^j^j ; ;r"rc r^\rSrSrSrS S\S\S\S\\4U4SjjjrS\ R4U4S jjr S r U=r $) TrOCRScaledWordEmbeddingCzT This module overrides nn.Embeddings' forward by multiplying with embeddings scale. rr padding_idx embed_scalec2>[TU]XU5 X@lgN)rrrD)rrrrCrDrs r r!TrOCRScaledWordEmbedding.__init__Hs  D&r"r#c<>[TU]U5UR-$rF)rr1rD)rr#rs r r1 TrOCRScaledWordEmbedding.forwardLswy)D,<,<<r?s@r rArACsJ's'3'S'_ghm_n''===r"rAc ^\rSrSrSrSS\S\S\\4U4Sjjjr\SS\S\S\\4Sjj5r \ R"5SS \ RS \4S jj5r SS \ RS\S \\4S jjrS rU=r$)"TrOCRSinusoidalPositionalEmbeddingPzDThis module produces sinusoidal positional embeddings of any length. num_positionsrrCc>[TU]5 SUlX lX0lUR XU5UlURS[R"S55 g)Nr _float_tensorr) rrrrrC get_embeddingweightsregister_bufferr+ FloatTensor)rrPrrCrs r r+TrOCRSinusoidalPositionalEmbedding.__init__SsP  *&))- T  _e.?.?.BCr"rcUS-n[R"S5US- - n[R"[R"U[R S9R 5U*-5n[R"U[R S9R 5RS5URS5-n[R"[R"U5[R"U5/SS9RUS5nUS-S:Xa,[R"U[R"US5/SS9nUbSXBSS24'UR[R"55$) z Build sinusoidal embeddings. This matches the implementation in tensor2tensor, but differs slightly from the description in Section 3.5 of "Attention Is All You Need". ri'r)r'rdimr)N)mathlogr+expr,int64rLr0catsincosviewzerostoget_default_dtype)rrrChalf_dimembs r rS0TrOCRSinusoidalPositionalEmbedding.get_embedding[s !A%hhuoA.ii XU[[AGGISDPQll>=CCEOOPQRUXUbUbcdUeeii338a@EEnVXY 1  !))S%++na"@AqIC  ""#CQ vve--/00r"r#r$cJUR5up4URXRU5RUR5nURS-U-nUR bX`R RS5:a+UR X`RUR5UlUR RUR5UlUR RSURS55RX4S5R5nU$)Nrrr)) size"create_position_ids_from_input_idsrCrdr(rTrSrrR index_selectrbdetach)rr#r$r2r3r%max_posxs r r1*TrOCRSinusoidalPositionalEmbedding.forwardns ~~' >>yJZJZ\rsvv    ""Q&0 << 7\\->->q-A#A--g7I7I4K[K[\DL||t'9'9: LL % %a):):2)> ? D DSSU V ] ] _r"cURU5R5n[R"USS9R U5U-U-nUR 5U-$)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`. rrY)ner;r+cumsumtype_asr-)rr#rCr$maskincremental_indicess r rkETrOCRSinusoidalPositionalEmbedding.create_position_ids_from_input_idssW||K(,,.$||Da8@@FI__cgg"'')K77r")rrrCrTrF)r)r6r7r8r9r:r;rr staticmethodrSr+no_gradr<r1rkr=r>r?s@r rNrNPsNDcD#DHUXMDD1c1#1HUXM11$ ]]_s&bc 8 847 8QYZ]Q^ 8 8r"rNc^\rSrSrSrSS\S\S\\S\\S\S\S \S \4U4S jjjr S \ RS \S\4Sjr SS\ RS\\ RS\\ \ RS\\ RS\\ RS\S\ \ R\\ R\\ \ R44SjjrSrU=r$)TrOCRAttentionz>Multi-headed attention from 'Attention Is All You Need' paper. embed_dim num_headskdimvdimdropout is_decoderbiasis_cross_attentionc &>[T U]5 X lUbUOUUlUbUOUUlX0lX`lX#-UlURU-UR:Xd[SURSUS35eURS-Ul Xpl [R"URX(S9Ul [R"URX(S9Ul[R"X"US9Ul[R"X"US9Ulg)Nz;embed_dim must be divisible by num_heads (got `embed_dim`: z and `num_heads`: z).g࿩r)rrr}rrr~rhead_dim ValueErrorscalingrrLineark_projv_projq_projout_proj) rconfigr}r~rrrrrrrs r rTrOCRAttention.__init__s " ,D)  ,D) " !.  )T^^;MdnnM]^;b" }}d* $ii 9@ ii 9@ ii 4@  )TB r"tensorr3r2cURX2URUR5RSS5R 5$)Nrr)rbr~r transpose contiguous)rrr3r2s r _shapeTrOCRAttention._shapes5{{3GQQRSUVWbbddr" hidden_stateskey_value_statespast_key_valueattention_masklayer_head_maskoutput_attentionsreturnc USLnUR5upn URU5UR-n U(aUb USn USn GO U(aEURUR U5SU5n URUR U5SU5n OUbyURUR U5SU5n URUR U5SU5n [ R"USU /SS9n [ R"USU /SS9n ODURUR U5SU5n URUR U5SU5n UR(aX4nXR-SUR4nURXU5R"U6n U R"U6n U R"U6n U RS5n[ R"XRSS55nUR5XR-X4:wa-[SXR-X4SUR535eUbvUR5USX4:wa"[S USX4SUR535eURXRX5U-nURXR-X5n[R R#USS9nUbUR5UR4:wa*[S UR4SUR535eURSSSS5URXRX5-nURXR-X5nU(a;URXRX5nURXR-X5nOSn[R R%UUR$UR&S 9n[ R"UU 5nUR5XR-XR4:wa5[S XRXR4SUR535eURXRXR5nURSS5nUR)XU 5nUR+U5nUUU4$) z#Input shape: Batch x Time x ChannelNrrr)rrYz$Attention weights should be of size z , but is z!Attention mask should be of size z/Head mask for a single layer should be of size ptrainingz `attn_output` should be of size )rjrrrrrr+r_rr~rrbbmmrrr functionalsoftmaxrrreshaper)rrrrrrrrr2tgt_lenr} query_states key_states value_states proj_shapesrc_len attn_weightsattn_weights_reshaped attn_probs attn_outputs r r1TrOCRAttention.forwards.T9"/"4"4"6i{{=1DLL@ ."<'*J)!,L T[[1A%BBLJ;;t{{3C'Db#NL  'T[[%?SIJ;;t{{='A2sKLN1$5z#BJJ 99nQ&7%FANLT[[%?SIJ;;t{{='A2sKL ??)7NNN*B > {{<#>CCZP __j1 #((*5 //!$yy/C/CAq/IJ    3#7"J J6nn8Lg7_6`a %%'(*   %""$a(BB 7a8R7SS\]k]p]p]r\st(,,S..'SVddL',,S>>-A7TL}},,\r,B  &##%$..):: Et~~FWEXY',,./1+//2q!<|?P?PQTVdVdfm?wwL',,S>>-A7TL  %1$5$5c>>7$\ !055cNN6JG]L$( !]]**<4<AAr") rr}rrrrr~rrrrr)NNFTF)NNNNF)r6r7r8r9r:r;rrLboolrr+r<rrr1r=r>r?s@r r{r{snH#" #(CC C sm C sm CCCC!CCBeU\\eCece 488<1526"'kB||kB#5<<0kB!u||!45 kB !. kB "%,,/ kB kB u||Xell3XeELL>Q5RR SkBkBr"r{c4^\rSrSrS\4U4SjjrSS\RS\\RS\\RS\\RS\\RS \\RS \\ \RS \\ S \\ 4S jjr Sr U=r $)TrOCRDecoderLayeri#rc f>[TU]5 URUl[ UURUR UR SS9UlURUl[URUl URUl [R"UR5UlUR (al[ UURUR UR"UR"UR SSS9Ul[R"UR5Ul[R("URUR*5Ul[R("UR*UR5Ul[R"UR5Ulg)NT)r}r~rr)r}r~rrrrr)rr hidden_sizer}r{decoder_attention_headsattention_dropout self_attnrr activation_function activation_fnactivation_dropoutr LayerNormself_attn_layer_normrcross_attention_hidden_size encoder_attnencoder_attn_layer_normrdecoder_ffn_dimfc1fc2final_layer_normrrrs r rTrOCRDecoderLayer.__init__$s7 ++' nn44,,  ~~ #F$>$>?"(";";$&LL$@!    ... 88777700#' !D ,.<<+GD (99T^^V-C-CD99V33T^^D " T^^ <r"rrencoder_hidden_statesencoder_attention_maskrcross_attn_layer_head_maskrr use_cachec TUn UbUSSOSn URUU UUUS9upn [RRXRURS9nX-nUR U5nSnSnUbnUn UbUSSOSnUR UUUUUUS9upn[RRXRURS9nX-nURU5nX-n Un URURU55n[RRXRURS9nURU5n[RRXRURS9nX-nURU5nU4nU(aUX4- nU (aUU 4- nU$)a Args: hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)` attention_mask (`torch.FloatTensor`): attention mask of size `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values. encoder_hidden_states (`torch.FloatTensor`): cross attention input to the layer of shape `(batch, seq_len, embed_dim)` encoder_attention_mask (`torch.FloatTensor`): encoder attention mask of size `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values. layer_head_mask (`torch.FloatTensor`): mask for attention heads in a given layer of size `(encoder_attention_heads,)`. cross_attn_layer_head_mask (`torch.FloatTensor`): mask for cross-attention heads in a given layer of size *(decoder_attention_heads,)*. past_key_value (`Tuple(torch.FloatTensor)`): cached past key and value projection states output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. Nr)rrrrrr)rrrrrr) rrrrrrrrrrrrr)rrrrrrrrrrresidualself_attn_past_key_valueself_attn_weightspresent_key_valuecross_attn_present_key_valuecross_attn_weightscross_attn_past_key_valueoutputss r r1TrOCRDecoderLayer.forwardFs<!:H9S>"1#5Y] >Bnn'3)+/ ?M? ; *; --m||VZVcVc-d  0 11-@ (,$! ,$H@N?Yrs(;_c %NRN_N_+!65 :8"3 O`O KM/KMM11-< >G  )+ +Gr") rrrr}rrrrrrr)NNNNNNFT)r6r7r8r9rrr+r<rrrr1r=r>r?s@r rr#s ={ =J268<9=26=A8<,1$([||[!.[ ( 5 [ !) 6 [ "%,,/ [%-U\\$:[!u||!45[$D>[D>[[r"rc,\rSrSr\rSrSrS/rSr Sr g)TrOCRPreTrainedModelimodelTrcBURRn[U[R[R 45(aWUR RRSUS9 URb%URRR5 gg[U[R5(adUR RRSUS9 URb2UR RURR5 ggg)Nr)meanstd) rinit_std isinstancerrConv1dr.datanormal_rzero_ EmbeddingrC)rmodulers r _init_weights"TrOCRPreTrainedModel._init_weightsskk"" fryy"))4 5 5 MM   & &CS & 9{{&   &&('  - - MM   & &CS & 9!!- ""6#5#56<<>..r"N) r6r7r8r9r config_classbase_model_prefixsupports_gradient_checkpointing_no_split_modulesrr=rr"r rrs!L&*#,- ?r"rcb^\rSrSrSrS\4U4SjjrSrSrS Sjr Sr U=r $) TrOCRDecoderiz Transformer decoder consisting of *config.decoder_layers* layers. Each layer is a [`TrOCRDecoderLayer`] Args: config: TrOCRConfig rc>[TU]U5 URUlURUlUR UlUR(a [R"UR5OSn[URURUR US9Ul UR(a&[UR UR5UlO@[%UR UR -S-URUR 5UlUR&(a&[(R*"UR5UlOSUl[(R,"[/UR05Vs/sHn[3U5PM sn5UlSUlUR95 gs snf)NrKrJrF)rrrdecoder_layerdrop layerdrop pad_token_idrCscale_embeddingr[sqrtrrA vocab_size embed_tokensuse_learned_position_embeddingsrmax_position_embeddingsembed_positionsrNlayernorm_embeddingrr ModuleListrangedecoder_layersrlayersgradient_checkpointing post_init)rrrD_rs r rTrOCRDecoder.__init__sQ  ~~ 11!..7=7M7Mdii 2 23SV 4   v1143C3CQ\   1 1#B6CaCacicucu#vD #E..1A1AAAE""  $D  % %')||F4F4F'GD $'+D $mmfNcNcHd$eHd1%6v%>Hd$ef &+#  %fsF;cUR$rFrrs r get_input_embeddings!TrOCRDecoder.get_input_embeddingss   r"cXlgrFrrvalues r set_input_embeddings!TrOCRDecoder.set_input_embeddingss!r"c 8U bU OURRn U bU OURRn U bU OURRn U bU OURRn UbUb [ S5eUb"Un UR SU RS5nO.Ub UR5SSnUSS2SS2S4n O [ S5eUbUSSRSOSnUcURU5nURR(aURXS9nOURXS9nUU-nURbURU5n[RRUURUR S9nU Rn[#X.X5nUbUb[%XHR&USS 9nUR((a/UR (aU (a[*R-S 5 S n U (aS OSnU (aS OSnU (aUbS OSnU (aS OSn[/XV/S S/5HnunnUcM UR5S[1UR25:wdM7[ SUS[1UR25SUR5SS35e [5UR25GH unnU (aUU4- nUR (a([6R8"/5nUUR::aMMUbUUOSnUR((aFUR (a5UR=UR>UUUUUbUUOSUbUUOSSU U 5 nOU"UUUUUbUUOSUbUUOSUU U S9 nUSnU (aUUU (aSOS4- nU (dMUUS4- nUcGMUUS4- nGM U (aUU4- nU (aUOSnU (d[ASUUUUU455$[CUUUUUS9$)aa Args: input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide it. Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and [`PreTrainedTokenizer.__call__`] for details. [What are input IDs?](../glossary#input-ids) attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*): Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`: - 1 for tokens that are **not masked**, - 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, encoder_sequence_length, hidden_size)`, *optional*): Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder. encoder_attention_mask (`torch.LongTensor` of shape `(batch_size, encoder_sequence_length)`, *optional*): Mask to avoid performing cross-attention on padding tokens indices of encoder input_ids. Mask values selected in `[0, 1]`: - 1 for tokens that are **not masked**, - 0 for tokens that are **masked**. [What are attention masks?](../glossary#attention-mask) head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*): Mask to nullify selected heads of the attention modules. Mask values selected in `[0, 1]`: - 1 indicates the head is **not masked**, - 0 indicates the head is **masked**. cross_attn_head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*): Mask to nullify selected heads of the attention modules in encoder to avoid performing cross-attention on hidden heads. Mask values selected in `[0, 1]`: - 1 indicates the head is **not masked**, - 0 indicates the head is **masked**. past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`): Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`) and 2 additional tensors of shape `(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)`. Contains pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention blocks) that can be used (see `past_key_values` input) to speed up sequential decoding. If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all `decoder_input_ids` of shape `(batch_size, sequence_length)`. inputs_embeds (`torch.FloatTensor` of shape `(batch_size, 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. output_attentions (`bool`, *optional*): Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned tensors for more detail. output_hidden_states (`bool`, *optional*): Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for more detail. return_dict (`bool`, *optional*): Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. NzTYou cannot specify both decoder_input_ids and decoder_inputs_embeds at the same timer)zEYou have to specify either decoder_input_ids or decoder_inputs_embedsrr)r$r)rz^`use_cache = True` is incompatible with gradient checkpointing. Setting `use_cache = False`...Fr head_maskcross_attn_head_maskzThe `z` should be specified for z layers, but it is for .)rrrrrrrrrrc30# UH nUcMUv M g7frFr).0vs r 'TrOCRDecoder.forward..smAms )last_hidden_statepast_key_valuesr attentionscross_attentions)"rroutput_hidden_statesruse_return_dictrrbr*rjrrrrrrrrr r r'rlogger warning_onceziplenr enumerater+randr_gradient_checkpointing_func__call__tupler )rr#rrrr rr inputs_embedsrrr return_dictinput input_shaper$ embed_posrall_hidden_statesall_self_attnsall_cross_attentionsnext_decoder_cache attn_mask mask_nameidx decoder_layerdropout_probabilityr layer_outputs next_caches r r1TrOCRDecoder.forwards|`2C1N-TXT_T_TqTq$8$D $++JjJj "+!6IDKKst t  "E!r5;;r?;I  &',,.s3K!!Q(+Ede eDSC^!3A!6!>#A&3t{{+;<$ {*DSEUDVW%NN,Q/03%r#,DKK"8 C#!m%55!}}&+jjn#&75D5P_S1VZN**t}} $ A A!**!")*&/&;IcN1E1Q(-W[% ! !.!#1*?+A7@7LYs^RV5I5U,S1[_#1&7' ! *!,M"}:KQQR'S&UU"  =#3"55(4(]1-=,??(_#9d -!1 1 +4'$ '5FXlm  9+&+%1   r")rrrrrrrrC) NNNNNNNNNNNN) r6r7r8r9r:rrrr r1r=r>r?s@r rrsP{>!" "#!!Y Y r"ra The TrOCR Model with a language modeling head. Can be used for summarization. This wrapper class is a helper class to correctly load pretrained checkpoints when the causal language model is used in combination with the [`EncoderDecoderModel`] framework. ) custom_introc.^\rSrSrU4SjrSrSrU=r$)TrOCRDecoderWrappericD>[TU]U5 [U5UlgrF)rrrdecoderrs r rTrOCRDecoderWrapper.__init__s  #F+ r"c&UR"U0UD6$rFr9)rargskwargss r r1TrOCRDecoderWrapper.forwards||T,V,,r"r<)r6r7r8r9rr1r=r>r?s@r r7r7s,--r"r7zy The TrOCR Decoder with a language modeling head. Can be used as the decoder part of [`EncoderDecoderModel`] and c ^\rSrSrS/rU4SjrSrSrSrSr Sr S r \ SS \ \RS \ \R S \ \R"S \ \RS\ \R S\ \R S\ \\\R"S\ \R"S\ \RS\ \S\ \S\ \S\ \S\\\44Sjj5r\S5rSrU=r$)TrOCRForCausalLMizoutput_projection.weightc >[R"U5nSUlSUl[TU]U5 [ U5Ul[R"URURSS9Ul UR5 g)NTFr)copydeepcopyris_encoder_decoderrrr7rrrrroutput_projectionrrs r rTrOCRForCausalLM.__init__shv& $)!  (0 !#6+=+=v?P?PW\!] r"cBURRR$rFrr9rrs r r%TrOCRForCausalLM.get_input_embeddingsszz!!...r"c8XRRlgrFrIrs r r %TrOCRForCausalLM.set_input_embeddingss*/ 'r"cUR$rFrFrs r get_output_embeddings&TrOCRForCausalLM.get_output_embeddingss%%%r"cXlgrFrN)rnew_embeddingss r set_output_embeddings&TrOCRForCausalLM.set_output_embeddingss!/r"c$XRlgrFrr9)rr9s r set_decoderTrOCRForCausalLM.set_decoders $ r"c.URR$rFrVrs r get_decoderTrOCRForCausalLM.get_decoderszz!!!r"r#rrrr rrr$labelsrrrr%rcLU bU OURRn U bU OURRn U bU OURRn URR UUUUUUUUU U U U S9 nUR US5nSnU bF[5nU"URSURR5U RS55nU (dU4USS-nUbU4U-$U$[UUURURURURS9$)a cross_attn_head_mask (`torch.Tensor` of shape `(decoder_layers, decoder_attention_heads)`, *optional*): Mask to nullify selected heads of the cross-attention modules. Mask values selected in `[0, 1]`: - 1 indicates the head is **not masked**, - 0 indicates the head is **masked**. labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): Labels for computing the masked language modeling loss. Indices should either be in `[0, ..., config.vocab_size]` or -100 (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]`. Example: ```python >>> from transformers import ( ... TrOCRConfig, ... TrOCRProcessor, ... TrOCRForCausalLM, ... ViTConfig, ... ViTModel, ... VisionEncoderDecoderModel, ... ) >>> import requests >>> from PIL import Image >>> # TrOCR is a decoder model and should be used within a VisionEncoderDecoderModel >>> # init vision2text model with random weights >>> encoder = ViTModel(ViTConfig()) >>> decoder = TrOCRForCausalLM(TrOCRConfig()) >>> model = VisionEncoderDecoderModel(encoder=encoder, decoder=decoder) >>> # If you want to start from the pretrained model, load the checkpoint with `VisionEncoderDecoderModel` >>> processor = TrOCRProcessor.from_pretrained("microsoft/trocr-base-handwritten") >>> model = VisionEncoderDecoderModel.from_pretrained("microsoft/trocr-base-handwritten") >>> # load image from the IAM dataset >>> url = "https://fki.tic.heia-fr.ch/static/img/a01-122-02.jpg" >>> image = Image.open(requests.get(url, stream=True).raw).convert("RGB") >>> pixel_values = processor(image, return_tensors="pt").pixel_values >>> text = "industry, ' Mr. Brown commented icily. ' Let us have a" >>> # training >>> model.config.decoder_start_token_id = processor.tokenizer.eos_token_id >>> model.config.pad_token_id = processor.tokenizer.pad_token_id >>> model.config.vocab_size = model.config.decoder.vocab_size >>> labels = processor.tokenizer(text, return_tensors="pt").input_ids >>> outputs = model(pixel_values, labels=labels) >>> loss = outputs.loss >>> round(loss.item(), 2) 5.30 >>> # inference >>> generated_ids = model.generate(pixel_values) >>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0] >>> generated_text 'industry, " Mr. Brown commented icily. " Let us have a' ```N) r#rrrr rrr$rrrr%rr)r)losslogitsrrrr)rrrrrr9rFrrbrrrrrr)rr#rrrr rrr$r\rrrr%rr_r^loss_fctoutputs r r1TrOCRForCausalLM.forwardsHX2C1N-TXT_T_TqTq$8$D $++JjJj &1%# UH/oRSTRUR55v M1 g7fr5)rlrdr()r past_statebeam_idxs r r2TrOCRForCausalLM._reorder_cache..qs1ncmU_--aZ=N=N1OPPcms7:)r#)rrfreordered_past layer_pasts ` r _reorder_cacheTrOCRForCausalLM._reorder_cachels8)J ncmnn N*r")rrF) NNNNNNNNNNNNN)r6r7r8r9_tied_weights_keysrrr rOrSrWrZrrr+ LongTensorr<rVrrrrr1rxrjr=r>r?s@r rArAs 55 /0&0%"1515=A=A,07;EI59-1$(,0/3&*s E,,-s !.s  ((9(9: s !))9)9 : s ELL) s 'u||4s "%e.?.?(@"ABs   1 12s ))*s D>s $D>s 'tns d^s  u77 8s s jr"rA)+r:rCr[typingrrrr+rtorch.nnr activationsr generationr modeling_attn_mask_utilsr r modeling_outputsr rmodeling_utilsrutilsrrconfiguration_trocrr get_loggerr6rrrrAModulerNr{rrrr7rA__all__rr"r rzs.6 )) %!)m-,,   H %;bll;4 =r|| =;8;8|RBRYYRBj~ ~B????$F 'F R-.-- ^+_^  ^B 5 6r"