3jȖSrSSKJr SSKrSSKJrJr SSKJr SSK J r J r SSK J r SS KJrJrJrJrJr SS KJr SS KJr SS KJr SS KJrJrJr SSKJrJ r SSK!J"r" SSK#J$r$ SSK%J&r& SSK'J(r(J)r)J*r*J+r+J,r,J-r- SSK.J/r/ \"SS9\"SS\555r0"SS\,5r1"SS\)5r2"SS\Rf5r4"S S!\(5r5"S"S#\+5r6"S$S%\&5r7"S&S'\*5r8\"S(S)\-55r9\"S*S+\955r:"S,S-\Rf5r;\"S.S9"S/S0\955r<\"S1S9"S2S3\955r="S4S5\$5r>"S6S7\Rf5r?"S8S9\Rf5r@"S:S;\Rf5rA"S<S=\Rf5rB"S>S?\Rf5rC"S@SA\Rf5rD\"SBSC\955rE\"SDS9"SESF\ \955rF/SGQrGg)HzPyTorch BEiT model.) dataclassN)Tensornn)initialization) BackboneMixinfilter_output_hidden_states)create_bidirectional_mask)BackboneOutputBaseModelOutputWithPoolingImageClassifierOutputMaskedLMOutputSemanticSegmenterOutput)PreTrainedModel)Unpack)#compile_compatible_method_lru_cache)TransformersKwargsauto_docstring torch_int)can_return_tuplemerge_with_config_defaults)capture_outputs)ResNetConvLayer) SwinDropPath) ViTAttention ViTEmbeddingsViTLayerViTMLPViTPatchEmbeddingsViTPreTrainedModel) BeitConfigz- Class for outputs of [`BeitModel`]. ) custom_introc\rSrSrSrSrg)BeitModelOutputWithPooling+a2 pooler_output (`torch.FloatTensor` of shape `(batch_size, hidden_size)`): Average of the last layer hidden states of the patch tokens (excluding the *[CLS]* token) if *config.use_mean_pooling* is set to True. If set to False, then the final hidden state of the *[CLS]* token will be returned. N)__name__ __module__ __qualname____firstlineno____doc____static_attributes__r(_/home/wildlama/miniconda3/lib/python3.13/site-packages/transformers/models/beit/modular_beit.pyr&r&+sr/r&c\rSrSrSrg)BeitPatchEmbeddings:r(Nr)r*r+r,r.r(r/r0r2r2:r/r2c\rSrSrS\SS4SjrS S\RS\RS-S\R4Sjjr S r g) BeitEmbeddings>configreturnNc[RRU5 [R"[R "SSUR 55UlUR(a6[R"[R "SSUR 55OSUl [U5Ul URUl URRnUR(a9[R"[R "SUS-UR 55OSUl[R "UR"5Ulg)Nr")rModule__init__ Parametertorchzeros hidden_size cls_tokenuse_mask_token mask_tokenr2patch_embeddings patch_size num_patches use_absolute_position_embeddingsposition_embeddingsDropouthidden_dropout_probdropout)selfr9rGs r0r=BeitEmbeddings.__init__?s 4 ekk!Q8J8J&KLQWQfQf",,u{{1a9K9K'LMlp 3F ; ++++77 66 LLQ a9K9KL M  zz&"<"<= r/ pixel_valuesbool_masked_poscURu p4nURU5nUR5upxnUbIURR XxS5n UR S5R U 5n USU - -X--nURR USS5n [R"X4SS9nURbX`RXdU5-nURU5nU$Nr"dim) shaperEsizerDexpand unsqueezetype_asrBr?catrIinterpolate_pos_encodingrL) rMrOrP_heightwidth embeddings batch_sizeseq_len mask_tokensmask cls_tokenss r0forwardBeitEmbeddings.forwardNs +001e**<8 !+!2 Q  &//00bIK",,R088ED#q4x0;3EEJ^^**:r2> YY 7Q?  # # /#&C&CJX]&^^J\\*- r/)rBrLrDrErFrIN) r)r*r+r,r#r=r?r BoolTensorrfr.r(r/r0r7r7>sS >z >d >$48ll))D0  r/r7c^\rSrSrS\SS4U4Sjjr\\"SS9S\\ \ 4S\ R4S j55r S S \ S\ R4S jjrS rU=r$)BeitRelativePositionBiashr9r:Nc>[TU]5 URn[U[[ 45(dX"4nUSUR -USUR -4UlSURS-S- SURS-S- -S-Ul[R"[R"URUR55UlgNrr"rr)superr= image_size isinstancetuplelistrF window_sizenum_relative_distancerr>r?r@num_attention_headsrelative_position_bias_table)rMr9rp __class__s r0r=!BeitRelativePositionBias.__init__is && *udm44$1J&qMV->->> 1 QWQbQb@bc&'$*:*:1*=&=&Aa$JZJZ[\J]F]`aFa%bef%f",.LL KK22F4N4N O- )r/ )maxsizertc SUS-S- SUS-S- -S-nUSUS-n[R"[R"[R"[R"US5[R"US5SS95SS9nUSS2SS2S4USS2SSS24- R SSS5R 5nUSS2SS2S4==USS- - ss'USS2SS2S4==USS- - ss'USS2SS2S4==SUS-S- -ss'[R"US-4S-URS 9nURS 5USS2SS24'US- USSS24'US- USS2S4'US- US 'U$) z This method creates the relative position index, modified to support arbitrary window sizes, as introduced in [MiDaS v3.1](https://huggingface.co/papers/2307.14460). rrr"rij)indexing) start_dimN)rWdtyperS)rr) r?flattenstackmeshgridarangepermute contiguousr@rsum)rtru window_areacoords_flattenrelative_coordsrelative_position_indexs r0 generate_relative_position_index9BeitRelativePositionBias.generate_relative_position_indexus"#[^!3a!7A A)B12&)>)BA&(=(A%&&r/r\cSURS-S- nSURS-S- nSUS-S- nSUS-S- nURnURn Xg-S-n USU S- n U RSXTS5R SSSS5n [ R RU [U5[U54SS9n U R SSSS5RU S- S5n [R"XU S- S/5n URU5nXRS5nURUSUS-S-USUS-S-S5nUR SSS5R5nU(a?[ R RURS5X34SS S 9RS5nURS5$) ze Modification of timm.models.beit.py: Attention._get_rel_pos_bias to support arbitrary window sizes. rrr"rNrSbilinear)rWmodeFrWr align_corners)rtrwrureshaperr functional interpolaterr?r[rviewrrYsqueeze)rMrtr\dim_size old_height old_width new_height new_width old_relative_position_bias_tableold_num_relative_distancenew_num_relative_distance old_sub_table new_sub_table new_relative_position_bias_tablerrelative_position_biass r0rf BeitRelativePositionBias.forwards!))!,,q0 ((++a/ Q'!+  A&* +/+L+L($($>$>!$.$:Q$>!89X;TWX;XY %--aKSSTUWXZ[]^_  11 :!6 )8L MT^2 &--aAq9AAB[^_B_acd +099 =VYZ=Z=\] ^, (#'"G"G "T!AB^B^_aBb!c"8!%>&003)# &?& gaj #&//22r/)rurwrt)FN)r)r*r+r,r#r= staticmethodrrrintr?rrboolrfr. __classcell__rxs@r0rkrkhsp  z  d  (4'eCHo'%,,'5'4-3T-3]b]i]i-3-3r/rkc0^\rSrSrS\4U4SjjrSrU=r$) BeitAttentionr9c >[TU]U5 [R"URUR UR -5Ul[R"URUR UR -SS9Ul[R"URUR UR -5Ul [R"UR UR -UR5Ul g)NF)bias) ror=rLinearrArvhead_dimq_projk_projv_projo_projrMr9rxs r0r=BeitAttention.__init__s  ii 2 2F4N4NQUQ^Q^4^_ ii 2 2F4N4NQUQ^Q^4^ejk ii 2 2F4N4NQUQ^Q^4^_ ii : :T]] JFL^L^_ r/)rrrr)r)r*r+r,r#r=r.rrs@r0rrs`z``r/rc\rSrSrSrg)BeitMLPr(Nr4r(r/r0rrr5r/rc\rSrSrSrg) BeitDropPathr(Nr4r(r/r0rrr5r/rc ^\rSrSrSrSS\S\4U4SjjjrSS\RS\RS-S \ S \ \ \ 4S-S \ \S \R4 S jjrSrU=r$) BeitLayerz?This corresponds to the Block class in the timm implementation.r9drop_path_ratec>[TU]5 URUlUS:a [U5O[R "5UlURnUS:a6[R"U[R"UR5-SS9OSUl US:a6[R"U[R"UR5-SS9OSUl UR(a[U5UlgSUlg)NrT) requires_gradg?)ror=rFrrIdentity drop_pathlayer_scale_init_valuer>r?onesrAlambda_1lambda_2use_relative_position_biasrkr)rMr9r init_valuesrxs r0r=BeitLayer.__init__s  ++9G#9Mn5SUS^S^S`33 ^ilm^mBLLuzz&2D2D'EEUY Zsv _jlm^mBLLuzz&2D2D'EEUY Zsv KQJkJk&>v&F#qu#r/N hidden_statesattention_maskr\ resolutionkwargsr:c URbFUupgX`R-XpR-4nURXURSS9n UbX-OU nUn URU5nUR"U4SU0UD6upUR U5nUR U-nURU5U -nUn URU5nURU5nUR U5nURU-nURU5U -nU$)Nr")rr) rrFrVlayernorm_before attentionrLrrlayernorm_aftermlpr) rMrrr\rrr^r_rtrresidualr]s r0rfBeitLayer.forwards6  & & 2&MF!__4e6NOK%)%@%@ @S@STU@V&A& ">  )    ]3  5 }5@ !,,]; /  ]3  5 }5@ r/)rrrrFr)rNFN)r)r*r+r,r-r#floatr=r?rrrrrrrrfr.rrs@r0rrsI vz v5 v v"/3).-1 &||& t+&#' & #s(Od* & +, & &&r/rc.\rSrSrS/rS/rSrSrSrSr g)BeitPreTrainedModeli rz.*relative_position_index.*Fc[R"X5 [U[5(a|[R "UR 5 URb [R "UR5 URb![R "UR5 gg[U[5(a![R "UR5 g[U[5(a[UR[R5(ak[R"URUR R"5 [R"UR$UR R"5 ggg)zInitialize the weightsN)r _init_weightsrqr7initzeros_rBrDrIrkrwrrrr> constant_r9rr)rMmodules r0r!BeitPreTrainedModel._init_weightss%%d3 fn - - KK(( )  , F--.))5 F6676  8 9 9 KK;; <  * *&//2<<88v 0R0RSv 0R0RS9+r/r(N) r)r*r+r,_no_split_modules"_keys_to_ignore_on_load_unexpected_supports_flash_attn_supports_flex_attnrr.r(r/r0rr s%$ *H)I& Tr/rc^\rSrSrSS\S\SS4U4Sjjjr\\"SS9\ SS \ RS \ RS-S \S \ RS-S \ \S\4 Sjj555rSrU=r$) BeitModeli$r9add_pooling_layerr:Nc >[TU]U5 Xl[U5UlUR (a [ U5OSUl[UR5Vs/sH+o1RU-[URS- S5- PM- nn[R"UVs/sH n[XS9PM sn5UlUR (a[R""5O([R$"UR&UR(S9UlU(a [-U5OSUlUR15 gs snfs snf)z^ add_pooling_layer (bool, *optional*, defaults to `True`): Whether to add a pooling layer Nr")reps)ror=r9r7r`!use_shared_relative_position_biasrkshared_position_biasrangenum_hidden_layersrmaxr ModuleListrlayersuse_mean_poolingr LayerNormrAlayer_norm_eps layernorm BeitPoolerpooler post_init)rMr9ridrop_path_ratesrrxs r0r=BeitModel.__init__&s   (0060X0X $V ,^b !W\\b\t\tVu VuQR ! !A %F,D,Dq,H!(L LVu  mmRa$bRaQYv%HRa$bc $44BKKM",,vGYGY_e_t_t:u ->j(4   %cs !2E)E F)tie_last_hidden_statesrOrPr\rrc URXS9nURSSn[URUUS9nURbZUupXRR -XRR -4n UR XURSS9n UbX-OU nUn UR Hn U "U 4UUUS.UD6n M URU 5nURbURU5OSn[XS9$) z bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, num_patches)`, *optional*): Boolean masked positions. Indicates which patches are masked (1) and which aren't (0). )rPrN)r9 inputs_embedsrr")r\r)rr\r)last_hidden_state pooler_output) r`rVr r9rrFrrrr&)rMrOrPr\rrembedding_outputrr^r_rtshared_relative_position_biasrlayersequence_output pooled_outputs r0rfBeitModel.forward?s' ??2  ) [[E!-)A%   M!..78< 8O O4UY )Oiir/)r9r`rrrr)Tr)r)r*r+r,r#rr=rrrr?rrirrr&rfr.rrs@r0rr$szdd2 E248)..2 -jll-j))D0-j#' -j  t+ -j +, -j $-j3 -jr/rcn^\rSrSrS\SS4U4SjjrS\RS\R4SjrSr U=r $) rirr9r:Nc>[TU]5 UR(a/[R"UR UR S9UlgSUlg)Nr)ror=rrrrArrrs r0r=BeitPooler.__init__ssA KQKbKbBLL++1F1F G hl r/rcURb,URUSS2SS2SS24RS55$USS2S4$)Nr"r)rmeanrMrs r0rfBeitPooler.forwardysDBF..B\t~~mAqr1H5::1=>ubopqstptbuur/)r) r)r*r+r,r#r=r?rrfr.rrs@r0rrrs: z d vU\\vellvvr/ra Beit Model transformer with a 'language' modeling head on top. BEiT does masked image modeling by predicting visual tokens of a Vector-Quantize Variational Autoencoder (VQ-VAE), whereas other vision models like ViT and DeiT predict RGB pixel values. As a result, this class is incompatible with [`AutoModelForMaskedImageModeling`], so you will need to use [`BeitForMaskedImageModeling`] directly if you wish to do masked image modeling with BEiT. c^\rSrSrS\SS4U4SjjrSr\\SS\ RS-S\ RS-S \ RS-S \ S \ RS-S \ \S\\-4S jj55rSrU=r$)BeitForMaskedImageModelingi~r9r:Nc@>[TU]U5 URUl[USS9Ul[ R "URURS9Ul [ R"URUR5Ul UR5 g)NFrr)ror= num_labelsrbeitrrrArrr vocab_sizelm_headrrs r0r=#BeitForMaskedImageModeling.__init__su   ++f> f&8&8f>S>STyy!3!3V5F5FG  r/cgrhr()rMs r0get_output_embeddings0BeitForMaskedImageModeling.get_output_embeddingssr/rOrPlabelsr\rrc (UR"U4UUUS.UD6nURnURU5nURUSS2SS245n Sn Ub [R "5n U "XU5n [ U U URURS9$)a bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, num_patches)`): Boolean masked positions. Indicates which patches are masked (1) and which aren't (0). labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*): Labels for computing the image 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 AutoImageProcessor, BeitForMaskedImageModeling >>> import torch >>> from PIL import Image >>> import requests >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = Image.open(requests.get(url, stream=True).raw) >>> image_processor = AutoImageProcessor.from_pretrained("microsoft/beit-base-patch16-224-pt22k") >>> model = BeitForMaskedImageModeling.from_pretrained("microsoft/beit-base-patch16-224-pt22k") >>> num_patches = (model.config.image_size // model.config.patch_size) ** 2 >>> pixel_values = image_processor(images=image, return_tensors="pt").pixel_values >>> # create random boolean mask of shape (batch_size, num_patches) >>> bool_masked_pos = torch.randint(low=0, high=2, size=(1, num_patches)).bool() >>> outputs = model(pixel_values, bool_masked_pos=bool_masked_pos) >>> loss, logits = outputs.loss, outputs.logits >>> list(logits.shape) [1, 196, 8192] ```)rPr\rNr"losslogitsr attentions) rrrrrCrossEntropyLossrrr") rMrOrPrr\rroutputsrprediction_scoresmasked_lm_lossloss_fcts r0rf"BeitForMaskedImageModeling.forwardsX))  +%=)    "33..9 LLAB)?@  **,H%&7&H&QN$!//))   r/)rrrr)NNNFN)r)r*r+r,r#r=rrrr?rrirrrrrrrfr.rrs@r0rr~s z d -137&*)..2 @ llT)@ ))D0@  t# @ #' @  t+ @ +,@   @ @ r/rz Beit Model transformer with an image classification head on top (a linear layer on top of the average of the final hidden states of the patch tokens) e.g. for ImageNet. c^\rSrSrS\SS4U4Sjjr\\S S\RS-S\RS-S\ S \ \ S\ \-4 S jj55rS rU=r$) BeitForImageClassificationir9r:Nc.>[TU]U5 URUl[USS9UlURS:a+[ R "URUR5O[ R"5Ul UR5 g)NTrr) ror=rrrrrrAr classifierrrs r0r=#BeitForImageClassification.__init__ss   ++f= OUN_N_bcNc"))F$6$68I8IJikititiv r/rOrr\rc UR"U4SU0UD6nURnURU5nSnUbURX'UR5n[ UUUR URS9$)ab labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*): Labels for computing the image 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). r\Nr)rrr, loss_functionr9r rr") rMrOrr\rr$rr!r s r0rf"BeitForImageClassification.forwards))  %=    -- /  %%fdkkBD$!//))   r/)rr,rNNF)r)r*r+r,r#r=rrr?rrrrrrr rfr.rrs@r0r*r*s z d -1&*).  llT)   t#  #'  +,  & &    r/r*c^\rSrSrS S\S\S\\\\4-S\S\\\\4-\-S\S\\\\4-S \S \4U4S jjjrS r U=r $) BeitConvLayeri in_channels out_channels kernel_sizestridepaddingrdilationgroups activationc b>[T U]5 [R"UUUUUUUUS9Ulg)N)r4r5r6r7r8r9r:r)ror=rConv2d convolution) rMr4r5r6r7r8rr9r:r;rxs r0r=BeitConvLayer.__init__s9 99#%#  r/)r>)rr"rFr"r"relu) r)r*r+r,rrrstrrr=r.rrs@r0r3r3s .//0*+    5c?*    uS#X&,   c3h'    r/r3c^\rSrSrS\S\S\SS4U4SjjrS\RS \\\4S\R4S jr S r U=r $) BeitPyramidPoolingBlocki. pool_scaler4channelsr:Ncv>[TU]5 [R"U5Ul[ X#SS9Ulg)Nr"r6)ror=rAdaptiveAvgPool2dpoolingr3conv)rMrDr4rErxs r0r= BeitPyramidPoolingBlock.__init__/s. ++J7 !+QG r/inputrWcURU5nURU5n[RR X2SSS9nU$)NrFr)rIrJrrr)rMrLrW hidden_states r0rfBeitPyramidPoolingBlock.forward4s@||E* yy. }}00zin0o r/)rJrI) r)r*r+r,rr=r?rrrrfr.rrs@r0rCrC.sXH3HSHCHDH U\\sCxU\\r/rCc^\rSrSrSrS\\S4S\S\SS4U4S jjrS \RS\ \R4S jr S r U=r $) BeitPyramidPoolingModulei;aK Pyramid Pooling Module (PPM) used in PSPNet. Args: pool_scales (tuple[int]): Pooling scales used in Pooling Pyramid Module. in_channels (int): Input channels. channels (int): Channels after modules, before conv_seg. Based on OpenMMLab's implementation, found in https://github.com/open-mmlab/mmsegmentation. pool_scales.r4rEr:Nc >[TU]5 XlX lX0l[ R "UVs/sH n[XBUS9PM sn5Ulgs snf)N)rDr4rE) ror=rRr4rErrrCblocks)rMrRr4rErDrxs r0r=!BeitPyramidPoolingModule.__init__HsY && mm#. "-J(:aij"-    sArcrUR5SSnURVs/sHo3"XS9PM sn$s snf)Nr)rW)rWrT)rMr original_sizeblocks r0rf BeitPyramidPoolingModule.forwardTs8%**,QR0 FJkkRkUm8kRRRs4)rTrEr4rR)r)r*r+r,r-rrrr=r?rrsrfr.rrs@r0rQrQ;s\   E#s(O  #  QT  Y]  SU\\Sd5<<6HSSr/rQc^\rSrSrSrS\SS4U4SjjrS\\RS\R4Sjr S \\RS\R4S jr S r U=r $) BeitUperHeadiYz Unified Perceptual Parsing for Scene Understanding. This head is the implementation of [UPerNet](https://huggingface.co/papers/1807.10221). Based on OpenMMLab's implementation, found in https://github.com/open-mmlab/mmsegmentation. r9r:Nc >[TU]5 URUlUR/S-UlURUl[ R"UR URSS9Ul [URURSUR 5Ul [URS[UR5UR --UR SSS9Ul[ R"5Ul[ R"5UlURSSHinUR R%[X R SS95 UR"R%[UR UR SSS95 Mk [[UR5UR -UR SSS9Ulg)Nr"rGrSrr6r8)ror=rRrAr4rErr=rr,rQ psp_modulesr3lenpsp_bottleneckr lateral_convs fpn_convsappendfpn_bottleneck)rMr9r4rxs r0r=BeitUperHead.__init__as| !--"../!3** ))DMM63D3DRST4      R MM  ,   R 3t'7'7#84==#H H MM   ]]_++CR0K    % %mK\]&^ _ NN ! !- t}}Z[ef"g h1,   !DMM 1 MM  r/rc|USn[R"U/URU5QSS9nURU5$rR)r?r[r_ra)rMrrNs r0 psp_forwardBeitUperHead.psp_forwardsA$R( yy,!P1A1A,1O!PVWX ""<00r/encoder_hidden_statesc &/n[URU5Hup4URU"U55 M URURU55 [ U5n[ US- SS5HFnX&S- R SSnX&S- [RRX&USSS9-X&S- 'MH /n[ US- 5H)nURURU"X&55 M+ URUS5 [ US- SS5H7n[RRXUSR SSSSS9X'M9 [R"USS9nURU5n URU 5n U $) Nr"rrSrrFrrT)ziprbrdrhr`rrVrrrrcr?r[rer,) rMrjlaterals lateral_convrNused_backbone_levelsr prev_shapefpn_outsoutputs r0rfBeitUperHead.forwards*-d.@.@BW*X &L OOL6 7+Y (()>?@ #8}+a/B7A!a%..qr2J&1uo 0I0I *:U1J1HUO8+a/0A OODNN1-hk: ;1  %+a/B7A--33 (1+"3"3AB"7jX]4HK899X1-$$X.( r/) rEr,rercr4rbrRrar_)r)r*r+r,r-r#r=rsr?rrhrfr.rrs@r0r[r[Ysa  z  d  D1ell);1 1 T%,,-?ELLr/r[c ^\rSrSrSrS S\S\S\S\\\\4-SS4 U4S jjjrS \ \ RS\ R4S jr S r U=r$) BeitFCNHeadia Fully Convolution Networks for Semantic Segmentation. This head is implemented of [FCNNet](https://huggingface.co/papers/1411.4038>). Args: config (BeitConfig): Configuration. in_channels kernel_size (int): The kernel size for convs in the head. Default: 3. dilation (int): The dilation rate for convs in the head. Default: 1. Based on OpenMMLab's implementation, found in https://github.com/open-mmlab/mmsegmentation. r9in_indexr6r9r:Nc &>[TU]5 URUlURUlUR UlURUl X l US-U-n[R"5Ul URS:aURR[URUR X5US95 [!URS- 5H=nURR[UR UR UUUS95 M? UR(a4[URUR -UR X3S-S9Ul[R$"UR UR&SS9Ulg)Nrr)r6r8r9r"r^rG)ror=rAr4auxiliary_channelsrEauxiliary_num_convs num_convsauxiliary_concat_input concat_inputrvrrconvsrdr3rconv_catr=rr,)rMr9rvr6r9 conv_paddingr]rxs r0r=BeitFCNHead.__init__sD !--11 33"99 #q(H4 ]]_ >>A  JJ  $$dmmmu  4>>A-. !!!  $/ ,!) /   )  4==0$--[qrbrDM))DMM63D3DRSTr/rjcXRnUnURH nU"U5nM UR(a%UR[R "X#/SS95nUR U5nU$)Nr"rT)rvr}r|r~r?r[r,)rMrjrrrJs r0rfBeitFCNHead.forwardse(7 JJD /M    MM%))X4MST*UVM 6 r/)rEr,r|r~r}r4rvrz)rrr")r)r*r+r,r-r#rrrr=rsr?rrfr.rrs@r0rurus no!U !U,/!UBE!UUX[`adfiai[jUj!U !U!UFT%,,-?ELLr/ruc ~^\rSrSrSrS S\S\S\SS4U4SjjjrS \RS\R4S jr S r U=r $) BeitFPNUpBlockiuE4x upsampling block: ConvTranspose → BN → GELU → ConvTranspose.rAr6r7r:Nc>[TU]5 [R"XX#S9Ul[R "U5Ul[R"5Ul[R"XX#S9Ul g)Nr6r7) ror=rConvTranspose2dconv_transpose1 BatchNorm2d normalizationGELUr;conv_transpose2)rMrAr6r7rxs r0r=BeitFPNUpBlock.__init__sX !11+Xcs^^K8'')!11+Xcsr/rcURU5nURU5nURU5nURU5nU$rh)rrr;rrs r0rfBeitFPNUpBlock.forwardsF,,]; **=9  6 ,,]; r/)r;rrr)rr) r)r*r+r,r-rr=r?rrfr.rrs@r0rrsSOtCtctstSWttU\\ellr/rc^\rSrSrSrS\4U4SjjrS\\RS4S\\RS44Sjr S r U=r $) BeitFPNNeckiz 4-level feature pyramid neck for BeiT. Produces x4 upsample, x2 upsample, identity, and x2 downsample outputs from the four selected ViT feature maps. r9c>[TU]5 [UR5Ul[ R "URURSSS9Ul[ R"SSS9Ul g)Nrr) ror=rrAfpn1rrfpn2 MaxPool2dfpn4rs r0r=BeitFPNNeck.__init__sX "6#5#56 &&v'9'96;M;M[\efg LLQq9 r/ feature_maps.r:cURUS5URUS5USURUS54$rnrrr)rMrs r0rfBeitFPNNeck.forwardsC IIl1o & IIl1o & O IIl1o &   r/r) r)r*r+r,r-r#r=rrr?rrfr.rrs@r0rrsI :z:  E%,,*;$< u||UXGXAY  r/rc^\rSrSrS\SS4U4Sjjr\\\S S\ RS-S\ RS-S\ S \ \ S\\-4 S jj555rS rU=r$) BeitForSemanticSegmentationir9r:Ncf>[TU]U5 URUl[USS9Ul[ UR R5S:wa [S5e[U5Ul [U5Ul UR(a [U5OSUlUR!5 g)NFrr]zBeitForSemanticSegmentation requires config.out_indices to be a list of 4 integers, specifying which features to use from the backbone. One can use [3, 5, 7, 11] in case of a base-sized architecture.)ror=rrrr`r9 out_indices ValueErrorrfpnr[ decode_headuse_auxiliary_headruauxiliary_headrrs r0r=$BeitForSemanticSegmentation.__init__s   ++f> t{{&& '1 ,-  v&(/5;5N5Nk&1TX r/rOrr\rc ^ ^^^Ub%URRS:Xa [S5eUR"U4SU0UD6nURmUR um pgnXpRR -mXRR -m[U UUU4SjURR55n URU 5n URU 5n Sn URbURU 5n Sn Ub;URU UURRU URRS9n [U U URUR S9$)a labels (`torch.LongTensor` of shape `(batch_size, height, width)`, *optional*): Ground truth semantic segmentation maps for computing the loss. Indices should be in `[0, ..., config.num_labels - 1]`. If `config.num_labels > 1`, a classification loss is computed (Cross-Entropy). Examples: ```python >>> from transformers import AutoImageProcessor, BeitForSemanticSegmentation >>> from PIL import Image >>> import requests >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = Image.open(requests.get(url, stream=True).raw) >>> image_processor = AutoImageProcessor.from_pretrained("microsoft/beit-base-finetuned-ade-640-640") >>> model = BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640") >>> inputs = image_processor(images=image, return_tensors="pt") >>> outputs = model(**inputs) >>> # logits are of shape (batch_size, num_labels, height, width) >>> logits = outputs.logits ```Nr"z/The number of labels should be greater than oner\c3># UH8nTUS- SS2SS24RSS5RTSTT5v M: g7f)r"NrrS) transposer).0rrarj patch_height patch_widths r0 6BeitForSemanticSegmentation.forward..UsP , "!a% (AB / 9 9!Q ? G G TVXdfq r r,sAA) ignore_indexauxiliary_logitsauxiliary_loss_weightr)r9rrrrrVrFrrrrrrr/semantic_loss_ignore_indexrrr")rMrOrr\rr$r]r^r_rr!rr rarjrrs @@@@r0rf#BeitForSemanticSegmentation.forward%s`B  $++"8"8A"=NO O))  %=   !( 5 5'3'9'9$ Au!7!77 {{555  [[,,  xx - !!,/    *#22<@   %%![[CC!1&*kk&G&G &D'!//))   r/)rrrrrr1)r)r*r+r,r#r=rr rr?rrrrrrrrfr.rrs@r0rrszd* -1&*). G llT)G  t#G #' G +, G ( ( G !G r/rzM BEiT backbone, to be used with frameworks like DETR and MaskFormer. c b^\rSrSrU4Sjr\\\S\S\ \ S\ 4Sj555r Sr U=r$) BeitBackboneircF>[TU]U5 [URS-5Vs/sHo!RPM snUl[ USS9UlUR(a [U5O[R"5Ul UR5 gs snf)Nr"Fr)ror=rrrA num_featuresrradd_fpnrrrrr)rMr9r]rxs r0r=BeitBackbone.__init__xsx  9>v?W?WZ[?[9\]9\A//9\]f> *0..;v&bkkm  ^sBrOrr:c (URup4pVXPRR-nX`RR-nUR"U40UD6n U Rn Sn [ UR U 5HiupXR;dMURR(a3U SS2SS2SS24n U RSS5n U RUSXx5n X4- n Mk URU 5n [U U RU RS9$)a Examples: ```python >>> from transformers import AutoImageProcessor, AutoBackbone >>> import torch >>> from PIL import Image >>> import requests >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = Image.open(requests.get(url, stream=True).raw) >>> processor = AutoImageProcessor.from_pretrained("microsoft/beit-base-patch16-224") >>> model = AutoBackbone.from_pretrained( ... "microsoft/beit-base-patch16-224", out_features=["stage1", "stage2", "stage3", "stage4"] ... ) >>> inputs = processor(image, return_tensors="pt") >>> outputs = model(**inputs) >>> feature_maps = outputs.feature_maps >>> list(feature_maps[-1].shape) [1, 768, 14, 14] ```r(Nr"rrS)rrr")rVr9rFrrrl stage_names out_featuresreshape_hidden_statesrrrr r")rMrOrrar]r^r_rrr$rrstagerNs r0rfBeitBackbone.forwards@(4'9'9$ v!7!77 {{555 ))L3F3--  #&t'7'7#G E)));;44#/12q#9L#/#9#9!Q#?L#/#7#7 B #bL/ $Hxx - %!//))  r/)rrr)r)r*r+r,r=rr rrrrr rfr.rrs@r0rrrsN  3 3 +,3   3 !3 r/r)r*rrrrr)Hr- dataclassesrr?rrrrbackbone_utilsrr masking_utilsr modeling_outputsr r r rrmodeling_utilsrprocessing_utilsr pytorch_utilsrutilsrrr utils.genericrrutils.output_capturingrresnet.modeling_resnetrswin.modeling_swinrvit.modeling_vitrrrrr r!configuration_beitr#r&r2r7r<rkrrrrrrrrr*r3rCrQr[rurrrr__all__r(r/r0rsF! &H6.&@BBI54-tt*  !;   , ']'TV3ryyV3r`L` f  < 77tT,TT.Jj#JjJjZ v vS !4S S l / !4/  / d O 4 bii SryyS