fThSrSSKrSSKrSSKJr SSKJrJrJrJ r J r SSK r SSK r SSKr SSK Jr SSKJrJrJr SSKJr SS KJr SS KJr SS KJr SS KJrJrJr SS K J!r!J"r" SSK#J$r$J%r%J&r&J'r'J(r( SSK)J*r*J+r+J,r, \'RZ"\.5r/Sr0SKS\ RbS\2S\2S\2S\2S\ Rb4 Sjjr3SLSjr4Sr5Sr6\"SS\$55r7\"SS\$55r8\"S S!\$55r9"S"S#\Rt5r;"S$S%\Rt5r<SMS&\RtS'\ RbS(\ RbS)\ RbS*\\ RbS+\2S,\24S-jjr="S.S/\Rt5r>"S0S1\Rt5r?"S2S3\5r@\%"S4S5\"55rA"S6S7\Rt5rB"S8S9\Rt5rC\%"S:S;9"S<S=\A55rD"S>S?\Rt5rE"S@SA\Rt5rF\%"SBS;9"SCSD\A55rG\%"SESF\A55rH\%"SGS;9"SHSI\A55rI/SJQrJg)NzPyTorch Siglip model.N) dataclass)AnyCallableOptionalTupleUnion)nn)BCEWithLogitsLossCrossEntropyLossMSELoss)_calculate_fan_in_and_fan_out)ACT2FN)_prepare_4d_attention_mask)GradientCheckpointingLayer)BaseModelOutputBaseModelOutputWithPoolingImageClassifierOutput)ALL_ATTENTION_FUNCTIONSPreTrainedModel) ModelOutputauto_docstringcan_return_tuplelogging torch_int) SiglipConfigSiglipTextConfigSiglipVisionConfigcSnXSU-- :d XSU--:a[R"SSS9 U"X1- U- 5nU"XA- U- 5nURSU-S- SU-S- 5 UR5 UR U[ R "S5-5 URU5 URX4S9 g)NchS[R"U[R"S5- 5-S- $)N?@)matherfsqrt)xs b/var/www/auris/envauris/lib/python3.13/site-packages/transformers/models/siglip/modeling_siglip.pynorm_cdf _trunc_normal_..norm_cdf,s(dhhq499S>122c99zjmean is more than 2 std from [a, b] in nn.init.trunc_normal_. The distribution of values may be incorrect.) stacklevelrr#)minmax) warningswarnuniform_erfinv_mul_r$r&add_clamp_)tensormeanstdabr)lus r(_trunc_normal_r>)s: 1s7{1s7{ 2  ;  !(c!"A!(c!"A OOAEAIq1uqy) NN KKdiin$% KK MMaMr+r7r8r9r:r;returnc[R"5 [USSX45 URU5R U5 SSS5 g!,(df  g=f)a=Fills the input Tensor with values drawn from a truncated normal distribution. The values are effectively drawn from the normal distribution :math:`\mathcal{N}( ext{mean}, ext{std}^2)` with values outside :math:`[a, b]` redrawn until they are within the bounds. The method used for generating the random values works best when :math:`a \leq ext{mean} \leq b`. NOTE: this 'tf' variant behaves closer to Tensorflow / JAX impl where the bounds [a, b] are applied when sampling the normal distribution with mean=0, std=1.0 and the result is subsequently scaled and shifted by the mean and std args. Args: tensor: an n-dimensional `torch.Tensor` mean: the mean of the normal distribution std: the standard deviation of the normal distribution a: the minimum cutoff value b: the maximum cutoff value rr"N)torchno_gradr>r4r5)r7r8r9r:r;s r(trunc_normal_tf_rCMs<* vq#q, Cd# s /A AcF[U5upEUS:XaUnOUS:XaUnO US:XaXE-S- nUW- nUS:Xa"[U[R"U5S- S9 gUS:XaB[R "5 UR [R"U5S9 SSS5 gUS :XaK[R"S U-5n[R "5 URU*U5 SSS5 g[S U35e!,(df  g=f!,(df  g=f) Nfan_infan_outfan_avgr,truncated_normalg۶%?r9normaluniformrzinvalid distribution ) r rCr$r&rArBnormal_r2 ValueError) r7scalemode distributionrErFdenomvariancebounds r(variance_scaling_rTgs3F;OF x    !Q&u}H))TYYx%8;N%NO  ! ]]_ NNtyy2N 3_  " !h,' ]]_ OOUFE *_0?@@__s5$DD D D c[USSS9 g)NrErHrOrPrTr7s r( lecun_normal_rYsf8:LMr+c[USSS9 g)NrErJrVrWrXs r(default_flax_embed_initr[sf8(Cr+c\rSrSr%SrSr\\R\ S'Sr \\R\ S'Sr \\ \RS4\ S'Sr \\ \RS4\ S'S rg) SiglipVisionModelOutputa Base class for vision model's outputs that also contains image embeddings of the pooling of the last hidden states. Args: image_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim)` *optional* returned when model is initialized with `with_projection=True`): The image embeddings obtained by applying the projection layer to the pooler_output. last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`): Sequence of hidden-states at the output of the last layer of the model. hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`): Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`): Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`. Attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads. N image_embedslast_hidden_state. hidden_states attentions)__name__ __module__ __qualname____firstlineno____doc__r_rrA FloatTensor__annotations__r`rarrb__static_attributes__rcr+r(r]r]sr*15L(5,,-459x 1 129=AM8E%"3"3S"89:A:>Ju00#567>r+r]c\rSrSr%SrSr\\R\ S'Sr \\R\ S'Sr \\ \RS4\ S'Sr \\ \RS4\ S'S rg) SiglipTextModelOutputa Base class for text model's outputs that also contains a pooling of the last hidden states. Args: text_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim)` *optional* returned when model is initialized with `with_projection=True`): The text embeddings obtained by applying the projection layer to the pooler_output. last_hidden_state (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`): Sequence of hidden-states at the output of the last layer of the model. hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`): Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`): Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, sequence_length)`. Attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads. N text_embedsr`.rarbrc)rdrerfrgrhrorrArirjr`rarrbrkrcr+r(rmrmsr*04K%++,359x 1 129=AM8E%"3"3S"89:A:>Ju00#567>r+rmc\rSrSr%SrSr\\R\ S'Sr \\R\ S'Sr \\R\ S'Sr \\R\ S'Sr \\R\ S'Sr\\ S 'Sr\\ S 'S \\4S jrS rg) SiglipOutputa Args: loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `return_loss` is `True`): Contrastive loss for image-text similarity. logits_per_image (`torch.FloatTensor` of shape `(image_batch_size, text_batch_size)`): The scaled dot product scores between `image_embeds` and `text_embeds`. This represents the image-text similarity scores. logits_per_text (`torch.FloatTensor` of shape `(text_batch_size, image_batch_size)`): The scaled dot product scores between `text_embeds` and `image_embeds`. This represents the text-image similarity scores. text_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim`): The text embeddings obtained by applying the projection layer to the pooled output of [`SiglipTextModel`]. image_embeds (`torch.FloatTensor` of shape `(batch_size, output_dim`): The image embeddings obtained by applying the projection layer to the pooled output of [`SiglipVisionModel`]. text_model_output (`BaseModelOutputWithPooling`): The output of the [`SiglipTextModel`]. vision_model_output (`BaseModelOutputWithPooling`): The output of the [`SiglipVisionModel`]. Nlosslogits_per_imagelogits_per_textror_text_model_outputvision_model_outputr?cJ^[U4SjTR555$)Nc3n># UH*nUS;aTUO[TU5R5v M, g7f))rvrwN)getattrto_tuple).0kselfs r( (SiglipOutput.to_tuple..s<   LLDGRYZ^`aRbRkRkRm m s25)tuplekeysr~s`r(r{SiglipOutput.to_tuples# YY[   r+rc)rdrerfrgrhrsrrArirjrtruror_rvrrwrrr{rkrcr+r(rqrqs()-D(5$$ %,48hu001837OXe//07/3K%++,304L(5,,-448186:3: %* r+rqc^\rSrSrS\4U4SjjrS\RS\S\S\R4Sjr S S \RS\R4S jjr S r U=r $) SiglipVisionEmbeddingsconfigc^>[TU]5 XlURUlUR UlUR Ul[R"URURUR UR SS9Ul UR UR -S-Ul URUl [R"URUR5UlURS[ R""UR5R%S5SS9 g)Nvalid) in_channels out_channels kernel_sizestridepaddingr, position_idsrF persistent)super__init__r hidden_size embed_dim image_size patch_sizer Conv2d num_channelspatch_embedding num_patches num_positions Embeddingposition_embeddingregister_bufferrAarangeexpandr~r __class__s r(rSiglipVisionEmbeddings.__init__s  ++ ++ ++!yy++??  !OOt>1D!--"$,,t/A/A4>>"R ^U\\$:L:L-M-T-TU\-]jopr+ embeddingsheightwidthr?cURSnURRRSn[RR 5(d%XE:Xa X#:XaURUR 5$URRRS5nURSnX R-nX0R-n [US-5n URSXU5nURSSSS5n[RRUX4SSS 9nURSSSS5RSSU5nU$) a This method allows to interpolate the pre-trained position encodings, to be able to use the model on higher resolution images. This method is also adapted to support torch.jit tracing and no class embeddings. Adapted from: - https://github.com/facebookresearch/dino/blob/de9ee3df6cf39fac952ab558447af1fa1365362a/vision_transformer.py#L174-L194, and - https://github.com/facebookresearch/dinov2/blob/e1277af2ba9496fbadf7aec6eba56e8d882d1e35/dinov2/models/vision_transformer.py#L179-L211 rrrg?rr,bicubicF)sizerO align_corners)shaperweightrAjit is_tracingr unsqueezerrreshapepermuter functional interpolateview) r~rrrrrpatch_pos_embeddim new_height new_widthsqrt_num_positionss r(interpolate_pos_encoding/SiglipVisionEmbeddings.interpolate_pos_encodings:!&&q) //66<O>O&PPJr+)rrrrrrrrF)rdrerfrgrrrATensorintrrirrk __classcell__rs@r(rrseq1q($5<<$$UX$]b]i]i$L E$5$5 Z_ZfZf  r+rc ^\rSrSrS\4U4SjjrS S\\RS\\RS\\RS\R4Sjjr S r U=r $) SiglipTextEmbeddingsi3rcN>[TU]5 URn[R"UR U5Ul[R"URU5UlURS[R"UR5RS5SS9 g)NrrFr) rrrr r vocab_sizetoken_embeddingmax_position_embeddingsrrrArrr~rrrs r(rSiglipTextEmbeddings.__init__4s && !||F,=,=yI"$,,v/M/My"Y  ELL)G)GHOOPWXej  r+ input_idsr inputs_embedsr?c<UbURSOURSnURRRSnXE:a[SUSU35eUcURSS2SU24nUcUR U5nURU5nX6-nU$)NrrzRSequence length must be less than max_position_embeddings (got `sequence length`: z and max_position_embeddings: )rrrrMrr)r~rrr seq_lengthmax_position_embeddingposition_embeddingsrs r(rSiglipTextEmbeddings.forward@s -6,AY__R(}GZGZ[]G^ !%!8!8!?!?!E!Ea!H  .d,<=S[TU]5 XlURUlUR UlURUR -UlURUR -UR:wa&[SURSUR S35eURS-Ul URUl SUl [R"URUR5Ul[R"URUR5Ul[R"URUR5Ul[R"URUR5Ulg)Nz;embed_dim must be divisible by num_heads (got `embed_dim`: z and `num_heads`: z).F)rrrrrnum_attention_heads num_headshead_dimrMrNattention_dropoutr is_causalr Lineark_projv_projq_projout_projrs r(rSiglipAttention.__init__us  ++33$..8 ==4>> )T^^ ;MdnnM]^NN#2' ]]D( // ii? ii? ii?  $..$..A r+raroutput_attentionsr?c URupEnURU5nURU5nURU5n UR XEUR UR 5RSS5nUR XEUR UR 5RSS5nU R XEUR UR 5RSS5n [n URRS:waTURRS:XaU(a[RS5 O[URRn U "UUUU UURURUR (dSO UR"S9upU R%XEU5R'5n UR)U 5n U(dSn X4$) z#Input shape: Batch x Time x Channelrr,eagersdpaz`torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True`. Falling back to eager attention. This warning can be removed using the argument `attn_implementation="eager"` when loading the model.)rrrN)rrrrrrrrrr_attn_implementationlogger warning_oncerrrNrrrrr) r~rarr batch_sizerrqueriesrvaluesattention_interfacerrs r(rSiglipAttention.forwards-:,?,?) ++m,{{=)]+,,zt~~t}}U__`acdeyyOYYZ[]^_ZT^^T]]S]]^_abc(? ;; + +w 6{{//69>O##L '>dkk>^>^&_#$7     nnJJ#}}C$,, % ! "))*)LWWY mmK0  L((r+) rrrrrrrrrrNrNF)rdrerfrgrhrrrrrArrboolrrrkrrs@r(rrrsGBu%79I%IJB.26,1 -)||-)!.-)$D> -) u||Xell33 4 -)-)r+rcb^\rSrSrU4SjrS\R S\R 4SjrSrU=r $) SiglipMLPic>[TU]5 Xl[URUl[ R"URUR5Ul [ R"URUR5Ul gN) rrrr hidden_act activation_fnr rrintermediate_sizefc1fc2rs r(rSiglipMLP.__init__sb  #F$5$5699V//1I1IJ99V55v7I7IJr+rar?clURU5nURU5nURU5nU$r)rrr)r~ras r(rSiglipMLP.forwards4/ **=9 / r+)rrrr) rdrerfrgrrArrrkrrs@r(rrs)KU\\ellr+rc ^\rSrSrS\\\44U4SjjrS S\RS\RS\ \ S\ \R4SjjrS rU=r$) SiglipEncoderLayerirc<>[TU]5 URUl[R "URUR S9Ul[U5Ul [R "URUR S9Ul [U5Ul g)Neps) rrrrr LayerNormlayer_norm_eps layer_norm1r self_attn layer_norm2rmlprs r(rSiglipEncoderLayer.__init__sm ++<<F $ u  ! $$r+rc6\rSrSr\rSrSr/SQrSr Sr Sr Sr g)SiglipPreTrainedModelisiglipT)rrrr#SiglipMultiheadAttentionPoolingHeadcV [U[5(a[UR[5(a URRR OURR n[ RRURRS[R"U5- S9 g[U[ R5(a[UR5 g[U[5(Ga[ RR!UR"R5 [ RR!UR$R5 [ RR!UR&R5 [ RR!UR(R5 [ RR+UR"R,5 [ RR+UR$R,5 [ RR+UR&R,5 [ RR+UR(R,5 g[U[.5(a[ RR!UR0R5 [ RR!UR2R5 [ RRUR0R,SS9 [ RRUR2R,SS9 g[U[45(a[ RR!UR6R85 [ RR!UR:R<R85 [ RR+UR:R>R85 g[U[@5(at[BRD"[BRF"S55nURHR8RKU5 URLR8RO5 g[U[P5(ak[ RRURRRURRR S-URRT-S9 g[U[ RV[ RX45(aM[[UR5 UR,b*[ RR+UR,5 gg[U[ R\5(aJUR,R8RO5 URR8RKS5 gg)zInitialize the weightsrrIgư>r"rN)/ isinstancerrr vision_configrr initrLrrnpr&rr[rxavier_uniform_rrrrzeros_biasrrrr1probedata attentionin_proj_weight in_proj_bias SiglipModelrAlogr7 logit_scalefill_ logit_biaszero_SiglipForImageClassification classifierinitializer_factorrrrYr#)r~rrlogit_scale_inits r( _init_weights#SiglipPreTrainedModel._init_weights s f4 5 5dkk<88 ))55[[,,  GGOOF55<  , ,$yyc):;     # # ) )*: ;    " " ( ( *  < = = GGOO!!((KK--994?$++B`B``  BII 6 7 7 &-- ({{&v{{+'  - - KK   " " $ MM   $ $S ).r+rcN) rdrerfrgr config_classbase_model_prefixsupports_gradient_checkpointing_no_split_modules_supports_flash_attn_2_supports_sdparIrkrcr+r(r/r/s-L &*#"N,*r+r/c ^\rSrSrSrS\4U4Sjjr\S S\\ RS\\ S\\ S\ 4S jj5r S rU=r$) SiglipEncoderi9z Transformer encoder consisting of `config.num_hidden_layers` self attention layers. Each layer is a [`SiglipEncoderLayer`]. Args: config: SiglipConfig rc>[TU]5 Xl[R"[ UR 5Vs/sHn[U5PM sn5UlSUl gs snfr) rrrr ModuleListrangenum_hidden_layersrlayersgradient_checkpointing)r~rrrs r(rSiglipEncoder.__init__BsS  mmvOgOgIh$iIhA%7%?Ih$ij &+#%jsA&rroutput_hidden_statesr?cFUbUOURRnUbUOURRnU(aSOSnU(aSOSnUnURH-nU(aXW4-nU"UUUS9n U SnU(dM%XiS4-nM/ U(aXW4-n[ UUUS9$)a Args: inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`): 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. 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) 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. Nrc)rrr)r`rarb)rrrZrWr) r~rrrrZencoder_statesall_attentionsra encoder_layer layer_outputss r(rSiglipEncoder.forwardIs<2C1N-TXT_T_TqTq$8$D $++JjJj  40d% ![[M#!/2B!B)"3M *!,M  !/3C2E!E) +.>>N+(%  r+)rrXrWr)rdrerfrgrhrrrrrArrrrrkrrs@r(rRrR9sl,|,26,0/3 < !.< $D> < 'tn <  < < r+rRc^\rSrSrS\4U4Sjjr\\S S\\ RS\\ RS\\ RS\\ S\\ S \ 4 S jj55r S rU=r$) SiglipTextTransformerirc>>[TU]5 XlURn[ U5Ul[ U5Ul[R"X!RS9Ul [R"X!R5UlURS:HUlg)Nr!flash_attention_2)rrrrrrrRencoderr r#r$final_layer_normrprojection_sizeheadr_use_flash_attention_2rs r(rSiglipTextTransformer.__init__sw  && .v6$V, " Y . 'tn .  $. . r+rbzK The text model from SigLIP without any head or projection on top. ) custom_introc^\rSrSr\rS\4U4SjjrS\R4Sjr Sr \ \ SS\ \RS\ \RS \ \RS \ \S \ \S\4 S jj55rS rU=r$)SiglipTextModelircd>[TU]U5 [U5UlUR 5 gr)rrrb text_model post_initrs r(rSiglipTextModel.__init__s&  /7 r+r?cBURRR$rrwrrrs r(get_input_embeddings$SiglipTextModel.get_input_embeddingss))999r+c8XRRlgrr{)r~rs r(set_input_embeddings$SiglipTextModel.set_input_embeddingss5:""2r+rrrrrZc(URUUUUUS9$)aT Examples: ```python >>> from transformers import AutoTokenizer, SiglipTextModel >>> model = SiglipTextModel.from_pretrained("google/siglip-base-patch16-224") >>> tokenizer = AutoTokenizer.from_pretrained("google/siglip-base-patch16-224") >>> # important: make sure to set padding="max_length" as that's how the model was trained >>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding="max_length", return_tensors="pt") >>> outputs = model(**inputs) >>> last_hidden_state = outputs.last_hidden_state >>> pooled_output = outputs.pooler_output # pooled (EOS token) states ```rrrrrZrw)r~rrrrrZs r(rSiglipTextModel.forwards)6)%/!5   r+rrr)rdrerfrgrrKrr Moduler|rrrrrArrrrrkrrs@r(rurus $L/ :bii:;-115/3,0/3  ELL) !. u||,  $D>  'tn   $  r+ruc z^\rSrSrS\4U4Sjjr\\S S\\ S\\ S\\ S\ 4Sjj55r S r U=r $) SiglipVisionTransformerircX>[TU]5 XlURn[ U5Ul[ U5Ul[R"X!RS9Ul [US5(dSO URUlUR(a[U5Ulgg)Nr!vision_use_headT)rrrrrrrRrer r#r$post_layernormhasattrruse_headr1rhrs r(r SiglipVisionTransformer.__init__s  && 08$V,  ll9:O:OP$+F4E$F$FFLbLb ==;FCDI r+rrZrr?cpUbUOURRnUbUOURRnURXS9nUR UUUS9nUR nUR U5nUR(aURU5OSn[UUURURS9$)N)r)rrrZrl) rrrZrrer`rrrhrrarb) r~rrrZrraror`rms r(rSiglipVisionTransformer.forward s2C1N-TXT_T_TqTq$8$D $++JjJj  h +/<<'/!5,8,  ,== //0AB8<  "344 )/')77&11   r+)rrrerhrrNNF)rdrerfrgrrrrrrrrrkrrs@r(rrsm D1 D-1/338  $D> 'tn  #+4.  $   r+rc:^\rSrSrSrS\4U4SjjrSrSrU=r $)r1i0zMultihead Attention Pooling.rc>[TU]5 [R"[R "SSUR 55Ul[RRUR URSS9Ul [R"UR URS9Ul [U5Ulg)NrT) batch_firstr!)rrr ParameterrArandnrr:MultiheadAttentionrr<r#r$ layernormrr(rs r(r,SiglipMultiheadAttentionPoolingHead.__init__3s \\%++aF4F4F"GH 44V5G5GIcIcqu4vf&8&8f>S>STV$r+cURSnURRUSS5nURX1U5SnUnUR U5nX@R U5-nUSS2S4$)Nrr)rr:repeatr<rr()r~ hidden_stater r:r+s r(r+SiglipMultiheadAttentionPoolingHead.forward;sr!''*  !!*a3~~e<HK ~~l3 ((<"88 AqD!!r+)r<rr(r:) rdrerfrgrhrrrrkrrs@r(r1r10s&%1% " "r+r1zM The vision model from SigLIP without any head or projection on top. c ^\rSrSr\rSrS\4U4SjjrS\R4Sjr \ \ S S\ \S\ \S \S\4S jj55rS rU=r$) SiglipVisionModeliHrrcd>[TU]U5 [U5UlUR 5 gr)rrr vision_modelrxrs r(rSiglipVisionModel.__init__Qs)  3F; r+r?cBURRR$r)rrrrs r(r|&SiglipVisionModel.get_input_embeddingsYs  ++;;;r+rrZrc&URUUUUS9$)an Examples: ```python >>> from PIL import Image >>> import requests >>> from transformers import AutoProcessor, SiglipVisionModel >>> model = SiglipVisionModel.from_pretrained("google/siglip-base-patch16-224") >>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = Image.open(requests.get(url, stream=True).raw) >>> inputs = processor(images=image, return_tensors="pt") >>> outputs = model(**inputs) >>> last_hidden_state = outputs.last_hidden_state >>> pooled_output = outputs.pooler_output # pooled features ```rrrZrr)r~rrrZrs r(rSiglipVisionModel.forward\s(<  %/!5%= !  r+rr)rdrerfrgrrKmain_input_namerr rr|rrrrrrrkrrs@r(rrHs &L$O1! 'tn ! #' ! $ ! ! r+rc^\rSrSr\rS\4U4Sjjr\SS\\ RS\\ RS\\ RS\\ S\\ S \ R4 S jj5r \SS \\ RS\\ S\\ S \ S \ R4 S jj5r\\SS\\ R S \\ RS\\ RS\\ R S\\ S\\ S\\ S \ S \4Sjj55rSrU=r$)r?irc>[TU]U5 [UR[5(d"[ S[ UR5S35e[UR[5(d"[ S[ UR5S35eURnURn[RU5n[RU5nURUl URUl [R"[ R""S55Ul[R"[ R""S55UlUR)5 g)NzMconfig.text_config is expected to be of type SiglipTextConfig but is of type .zQconfig.vision_config is expected to be of type SiglipVisionConfig but is of type r)rrr3 text_configr TypeErrortyper4rru _from_configrrwrr rrArrArCrx)r~rrr4rwrrs r(rSiglipModel.__init__s"  &,,.>??++,-Q0  &..0BCC--./q2  (( ,, %11+> (55mD %//(55<< A7,,u{{1~6 r+rrrrrZr?cUbUOURRnUbUOURRnURUUUUUS9nURnU$)a Returns: text_features (`torch.FloatTensor` of shape `(batch_size, output_dim`): The text embeddings obtained by applying the projection layer to the pooled output of [`SiglipTextModel`]. Examples: ```python >>> from transformers import AutoTokenizer, AutoModel >>> import torch >>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224") >>> tokenizer = AutoTokenizer.from_pretrained("google/siglip-base-patch16-224") >>> # important: make sure to set padding="max_length" as that's how the model was trained >>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding="max_length", return_tensors="pt") >>> with torch.no_grad(): ... text_features = model.get_text_features(**inputs) ```r)rrrZrwrm)r~rrrrrZ text_outputsrps r(get_text_featuresSiglipModel.get_text_featuressr:2C1N-TXT_T_TqTq$8$D $++JjJj 48??)%/!5 4C4 %22 r+rrcUbUOURRnUbUOURRnURUUUUS9nURnU$)a Returns: image_features (`torch.FloatTensor` of shape `(batch_size, output_dim`): The image embeddings obtained by applying the projection layer to the pooled output of [`SiglipVisionModel`]. Examples: ```python >>> from PIL import Image >>> import requests >>> from transformers import AutoProcessor, AutoModel >>> import torch >>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224") >>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = Image.open(requests.get(url, stream=True).raw) >>> inputs = processor(images=image, return_tensors="pt") >>> with torch.no_grad(): ... image_features = model.get_image_features(**inputs) ```r)rrrZrrm)r~rrrZrvision_outputsrps r(get_image_featuresSiglipModel.get_image_featuressrB2C1N-TXT_T_TqTq$8$D $++JjJj 6:5F5F%/!5%= 6G6 '44 r+ return_lossc UbUOURRnUbUOURRnURUUUUS9n UR UUUUUS9n U R n U R n XR SSSS9- n XR SSSS9- n [R"XR5RU R55n URRU R5URRU R5pXR5-U-n U R5nSnU(a[R"U R!S5U RS 9n[R""U 5*SU--n[R$R&R)UU -5n[R*"USS 9*nUR-5n[/UUU U U U U S 9$) a return_loss (`bool`, *optional*): Whether or not to return the contrastive loss. Examples: ```python >>> from PIL import Image >>> import requests >>> from transformers import AutoProcessor, AutoModel >>> import torch >>> model = AutoModel.from_pretrained("google/siglip-base-patch16-224") >>> processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224") >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = Image.open(requests.get(url, stream=True).raw) >>> texts = ["a photo of 2 cats", "a photo of 2 dogs"] >>> # important: we pass `padding=max_length` since the model was trained with this >>> inputs = processor(text=texts, images=image, padding="max_length", return_tensors="pt") >>> with torch.no_grad(): ... outputs = model(**inputs) >>> logits_per_image = outputs.logits_per_image >>> probs = torch.sigmoid(logits_per_image) # these are the probabilities >>> print(f"{probs[0][0]:.1%} that image 0 is '{texts[0]}'") 31.9% that image 0 is 'a photo of 2 cats' ```Nrrr,rT)rrkeepdimr)devicer)rsrtruror_rvrw)rrrZrrwrmnormrArtrrrArCexpeyer ones_liker r logsigmoidsumr8rq)r~rrrrrrrZrrrr_rorurArCrtrsrm1_diag1logliknlls r(rSiglipModel.forwardsX2C1N-TXT_T_TqTq$8$D $++JjJj 6:5F5F%/!5%= 6G6 48??)%/!5 4C4 &33 "00 $&7&7!T&7&RR !$4$4qb$$4$OO  ,,{NN4D4G4G HZHZ4[\"&"2"2"5"5k6H6H"I4??K]K]^i^p^pKqZ)OO,== J*,,. ))O003O + 'tn +   ++Z59,0/3). .u001.$D>.'tn . #' .    ..`15481537&*,0/3).^ E,,-^ u001^ !. ^ u//0 ^ d^ ^ $D>^ 'tn^ #'^  ^ ^ r+r?z SigLIP vision encoder with an image classification head on top (a linear layer on top of the pooled final hidden states of the patch tokens) e.g. for ImageNet. c^\rSrSrSrS\SS4U4Sjjr\\S S\ \ RS\ \ RS\ \ S \ \ S \ S\ 4 S jj55rS rU=r$)rEihrrr?Nc>[TU]U5 URUl[R UR 5nUR UlURS:a5[R"UR RUR5O[R"5Ul UR5 g)Nr) rr num_labelsrrr4rr rrIdentityrFrx)r~rrrs r(r%SiglipForImageClassification.__init__qs   ++)55f6J6JK (55OUN_N_bcNcBIIf**668I8I Jikititiv  r+labelsrrZrcUbUOURRnUbUOURRnURUUUUS9nURn[ R "USS9nURU5nSn UGbURUR5nURRcURS:XaSURl OoURS:aNUR[ R:XdUR[ R:XaSURl OSURl URRS:XaI[5n URS:Xa&U "UR!5UR!55n OU "X5n OURRS:Xa=[#5n U "UR%SUR5UR%S55n O,URRS:Xa['5n U "X5n [)U UUR*UR,S 9$) a\ 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, SiglipForImageClassification >>> import torch >>> from PIL import Image >>> import requests >>> torch.manual_seed(3) # doctest: +IGNORE_RESULT >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> image = Image.open(requests.get(url, stream=True).raw) >>> # note: we are loading a `SiglipModel` from the hub here, >>> # so the head will be randomly initialized, hence the predictions will be random if seed is not set above. >>> image_processor = AutoImageProcessor.from_pretrained("google/siglip-base-patch16-224") >>> model = SiglipForImageClassification.from_pretrained("google/siglip-base-patch16-224") >>> inputs = image_processor(images=image, return_tensors="pt") >>> outputs = model(**inputs) >>> logits = outputs.logits >>> # model predicts one of the two classes >>> predicted_class_idx = logits.argmax(-1).item() >>> print("Predicted class:", model.config.id2label[predicted_class_idx]) Predicted class: LABEL_1 ```N)rrZrrr regressionsingle_label_classificationmulti_label_classificationr)rslogitsrarb)rrrZrr`rAr8rFrr problem_typerrlongrr squeezer rr rrarb) r~rrrrZrr,sequence_outputrrsloss_fcts r(r$SiglipForImageClassification.forwardsR2C1N-TXT_T_TqTq$8$D $++JjJj /3.?.? /!5%= /@/ "33 **_!<1  YYv}}-F{{''/??a'/;DKK,__q(fllejj.HFLL\a\e\eLe/LDKK,/KDKK,{{''<7"9??a'#FNN$4fnn6FGD#F3D))-JJ+- B @&++b/R))-II,./$!//))   r+)rFrr)NNNNF)rdrerfrgrrrrrrrArrrrrkrrs@r(rErEhs%O|$04)-,0/3). X u||,X &X $D> X 'tn X #' X  X X r+rE)r?r/rurrE)rr"gr#)r"rErJ)r)Krhr$r0 dataclassesrtypingrrrrrnumpyr6rAtorch.utils.checkpointr torch.nnr r r torch.nn.initr activationsrmodeling_attn_mask_utilsrmodeling_layersrmodeling_outputsrrrmodeling_utilsrrutilsrrrrrconfiguration_sigliprrr get_loggerrdr r>rfloatrCrTrYr[r]rmrqrrrrrrrr/rRrbrurr1rr?rE__all__rcr+r(rs !88 AA7!B9bbFVVTT   H %! J\_$ LL$ %$27$BG$SX$ \\$4A2ND ?k? ?8 ?K? ?8 ! ;!  ! HERYYER%299%^% II% <<% % << % U\\* %  %%.D)biiD)P  -3-`;*O;*;*~M BIIM `< BII< ~ 0 +0  0 f- bii- `""))"0 2 -2  2 jb 'b b J o #8o  o d r+