fThhSSKJr SSKrSSKJr SSKJs Jr SSKJrJ r J r SSK J r J r Jr SSKJrJrJrJrJrJrJrJrJrJrJrJrJr SSKJr "SS \ 5r"S S \5r "S S \ 5r!"SS\5r""SS\5r#"SS\5r$"SS\RJ5r&"SS\5r'"SS\5r("SS\5r)"SS\5r*"SS\5r+"S S!\5r,"S"S#\5r-/S$Qr.g)%)OptionalN)BCEWithLogitsLossCrossEntropyLossMSELoss) SiglipConfigSiglipTextConfigSiglipVisionConfig) BaseModelOutputBaseModelOutputWithPoolingImageClassifierOutputSiglipForImageClassification SiglipModel#SiglipMultiheadAttentionPoolingHead SiglipOutputSiglipPreTrainedModelSiglipTextModelSiglipTextModelOutputSiglipVisionModelSiglipVisionModelOutputSiglipVisionTransformer)_prepare_4d_attention_maskc\rSrSrSrg)Siglip2TextConfig*N__name__ __module__ __qualname____firstlineno____static_attributes__rc/var/www/auris/envauris/lib/python3.13/site-packages/transformers/models/siglip2/modular_siglip2.pyrr*r#rcD^\rSrSrSrSU4SjjrSrU=r$)Siglip2VisionConfig.a This is the configuration class to store the configuration of a [`Siglip2VisionModel`]. It is used to instantiate a Siglip2 vision encoder according to the specified arguments, defining the model architecture. Instantiating a configuration with the defaults will yield a similar configuration to that of the vision encoder of the Siglip2 [google/siglip2-base-patch16-naflex](https://huggingface.co/google/siglip2-base-patch16-naflex) architecture. Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the documentation from [`PretrainedConfig`] for more information. Args: hidden_size (`int`, *optional*, defaults to 768): Dimensionality of the encoder layers and the pooler layer. intermediate_size (`int`, *optional*, defaults to 3072): Dimensionality of the "intermediate" (i.e., feed-forward) layer in the Transformer encoder. num_hidden_layers (`int`, *optional*, defaults to 12): Number of hidden layers in the Transformer encoder. num_attention_heads (`int`, *optional*, defaults to 12): Number of attention heads for each attention layer in the Transformer encoder. num_channels (`int`, *optional*, defaults to 3): Number of channels in the input images. num_patches (`int`, *optional*, defaults to 256): The number of patches in the image with the size of (`patch_size`, `patch_size`). The image is resized to fill maximum of this number of patches, and to preserve the aspect ratio. In case the resulted number of patches is lower, the image is padded in "patch" dimension. patch_size (`int`, *optional*, defaults to 16): The size (resolution) of each patch. hidden_act (`str` or `function`, *optional*, defaults to `"gelu_pytorch_tanh"`): The non-linear activation function (function or string) in the encoder and pooler. If string, `"gelu"`, `"relu"`, `"selu"` and `"gelu_new"` `"quick_gelu"` are supported. layer_norm_eps (`float`, *optional*, defaults to 1e-06): The epsilon used by the layer normalization layers. attention_dropout (`float`, *optional*, defaults to 0.0): The dropout ratio for the attention probabilities. Example: ```python >>> from transformers import Siglip2VisionConfig, Siglip2VisionModel >>> # Initializing a Siglip2VisionConfig with google/siglip2-base-patch16-naflex style configuration >>> configuration = Siglip2VisionConfig() >>> # Initializing a Siglip2VisionModel (with random weights) from the google/siglip2-base-patch16-naflex style configuration >>> model = Siglip2VisionModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ```c  6>[T U]"S0U D6 X`lU?g)Nr)super__init__ num_patches image_size) self hidden_sizeintermediate_sizenum_hidden_layersnum_attention_heads num_channelsr, patch_size hidden_actlayer_norm_epsattention_dropoutkwargs __class__s r$r+Siglip2VisionConfig.__init__as  "6"& Or#)r,) ii r;rgelu_pytorch_tanhgư>g)rrr r!__doc__r+r" __classcell__r9s@r$r'r'.s30 h&r#r'c\rSrSrSrg) Siglip2ConfigtrNrrr#r$rCrCtr%r#rCc\rSrSrSrg)Siglip2VisionOutputxrNrrr#r$rFrFxr%r#rFc\rSrSrSrg)Siglip2TextOutput|rNrrr#r$rIrI|r%r#rIc\rSrSrSrg) Siglip2OutputrNrrr#r$rLrLr%r#rLc ^\rSrSrS\4U4Sjjr\S\RS\RS\ S\R4Sj5r S \RS\RS\R4S jr S rU=r$) Siglip2VisionEmbeddingsconfigc>[TU]5 XlURUlUR Ul[ R"URUR -UR -URS9Ul URUl [URS-5Ul [ R"URUR5Ulg)N) in_features out_featuresg?)r*r+rQr/ embed_dimr4nnLinearr3patch_embeddingr,intposition_embedding_size Embeddingposition_embeddingr.rQr9s r$r+ Siglip2VisionEmbeddings.__init__s  ++ ++!yy++doo=O  "--'*4+;+;S+@'A$"$,,t/?/?"Pr#positional_embeddingsspatial_shapes max_lengthreturnc NURSnURSnURn[R"X2U4URUS9nUR SSS5R S5nURRS:XaUR[R5n[U5HnnXup[R"UX4SSS S 9n U RXHU -5RSS5n U RU5n XUS X-24'U SXgX-S 24'Mp U$) a  Resize positional embeddings to image-specific size and pad to a fixed size. Args: positional_embeddings (`torch.Tensor`): Position embeddings of shape (height, width, embed_dim) spatial_shapes (`torch.LongTensor`): Spatial shapes of shape (batch_size, 2) to resize the positional embeddings to max_length (`int`): Maximum length of the positional embeddings to pad resized positional embeddings to Returns: `torch.Tensor`: Embeddings of shape (batch_size, max_length, embed_dim) r)devicedtypecpubilinearFT)sizemode align_corners antialiasN)shaperftorchemptyrepermute unsqueezetypetofloat32rangeF interpolatereshape transpose) r_r`ra batch_sizerU source_dtyperesulted_positional_embeddingsiheightwidthresized_embeddingss r$resize_positional_embeddings4Siglip2VisionEmbeddings.resize_positional_embeddingssI($))!, )//3 ,22 ). Y /(//* &!6 = =aA F P PQR S ! ' ' , , 5$9$<$.>+> ?BTUVBW *fn.>+> ?%#(.-r# pixel_valuesc:URRRnURURUS95nURRR UR UR S5nURXRURSS9nXF-nU$)a Args: pixel_values (`torch.FloatTensor`): Pixel values of shape (batch_size, max_num_patches, num_channels * patch_size * patch_size) spatial_shapes (`List[Tuple[int, int]]`): Spatial shapes of shape (batch_size, 2) to resize the positional embeddings to )rfrdrh)ra) rXweightrfrur\rzrZrro)r.rr` target_dtype patch_embedsr_resized_positional_embeddings embeddingss r$forwardSiglip2VisionEmbeddings.forwards++2288 ++LOO,O,OP !% 7 7 > > F F  ( ($*F*F! )-(I(I !l>P>PQR>S)J) % "A r#)rQrUr,rXr4r\rZ)rrr r!r'r+ staticmethodrpTensor LongTensorrYr FloatTensorrr"r@rAs@r$rOrOs Q2 Q8.$||8.((8.8.  8.8.tE$5$5uGWGW\a\h\hr#rOc ^\rSrSrS\4U4SjjrS S\RS\RS\RS\ \ S\ \ S \ 4 S jjr S rU=r$) Siglip2VisionTransformerrQcJ>[TU]5 URS:HUlg)Nflash_attention_2)r*r+_attn_implementation_use_flash_attention_2r]s r$r+!Siglip2VisionTransformer.__init__s" &,&A&AEX&X#r#rattention_maskr`output_attentionsoutput_hidden_statesrbcUbUOURRnUbUOURRnURX5nUb'UR(d[ X&R 5nOUnURUUUUS9nURn URU 5n UR(aURX5OSn [U U URURS9$)z spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`): Tensor containing the spatial dimensions (height, width) of the input images. N) inputs_embedsrrr)last_hidden_state pooler_output hidden_states attentions)rQrrrrrrfencoderrpost_layernormuse_headheadr rr) r.rrr`rrrencoder_attention_maskencoder_outputsrrs r$r Siglip2VisionTransformer.forwards2C1N-TXT_T_TqTq$8$D $++JjJj  E  %d.I.I%?PcPc%d "%3 "+/<<'1/!5 ,8, ,== //0ABHL  "3D[_ )/')77&11   r#)rNN)rrr r!r'r+rprrrrboolr rr"r@rAs@r$rrsvY2Y-1/3 * ''*  * (( * $D> * 'tn *  $* * r#rc\rSrSrSrg)Siglip2PreTrainedModelirNrrr#r$rrr%r#rc\rSrSrSrg)Siglip2TextModeli rNrrr#r$rr r%r#rc^\rSrSrS\4U4SjjrS S\RS\\RS\R4Sjjr Sr U=r $) $Siglip2MultiheadAttentionPoolingHeadi$rQcF>[TU]U5 URUlgN)r*r+r2 num_headsr]s r$r+-Siglip2MultiheadAttentionPoolingHead.__init__%s  33r# hidden_staterrbcURSnURRUSS5nUbcURSURSpe[X!RU5nURSUR US5nUR SXV5nURXAXS9SnUnURU5nXpRU5-nUSS2S4$)Nrrhrd) attn_mask) roproberepeatrrfrrz attention layernormmlp)r.rrr|r target_len source_lenresiduals r$r,Siglip2MultiheadAttentionPoolingHead.forward)s!''*  !!*a3  %%*[[^\5G5G5J 7HZHZ\fgN+221dnnjRSTN+33B ON~~e<~bcde ~~l3 ((<"88 AqD!!r#)rr) rrr r!r'r+rprrrr"r@rAs@r$rr$sC424"ELL"(5<>> from PIL import Image >>> import requests >>> from transformers import AutoProcessor, Siglip2VisionModel >>> model = Siglip2VisionModel.from_pretrained("google/siglip2-base-patch16-224") >>> processor = AutoProcessor.from_pretrained("google/siglip2-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 ```rrr`rr) vision_model)r.rrr`rrs r$rSiglip2VisionModel.forward>s,B  %/)/!5 !  r#rr) rrr r!rprrrrrr rr"rr#r$rr<sf-1/3 ' ''' $ll' (( ' $D> ' 'tn '  $' ' r#rc\rSrSrSS\\R S\\RS\\RS\\ S\\ S\R 4 S jjr SS \\RS\\R S\\RS\\RS \\RS \\RS \\ S\\ S\\ S\ 4Sjjr Sr g) Siglip2ModelihNrrr`rrrbcUbUOURRnUbUOURRnURUUUUUS9nURnU$)a< pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*): Mask to avoid performing attention on padding pixel indices. spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`): Tensor containing the spatial dimensions (height, width) of the input images. 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 [`Siglip2VisionModel`]. Examples: ```python >>> from PIL import Image >>> import requests >>> from transformers import AutoProcessor, AutoModel >>> import torch >>> model = AutoModel.from_pretrained("google/siglip2-base-patch16-224") >>> processor = AutoProcessor.from_pretrained("google/siglip2-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)rQrrrr)r.rrr`rrvision_outputs pooled_outputs r$get_image_featuresSiglip2Model.get_image_featuresjsuN2C1N-TXT_T_TqTq$8$D $++JjJj 6:5F5F%/)/!5 6G6 '44 r# input_idsr position_ids return_lossc UbUOURRnU bU OURRn URUUUUU S9n UR UUUUU S9n U R n U R n XR SSSS9- n XR SSSS9- n [R"XR5RU R55nURRU R5URRU R5nnXR5-U-nUR5nSnU(a[R"UR!S5URS 9n[R""U5*SU--n[R$R&R)UU-5n[R*"USS 9*nUR-5n[/UUUU U U U S 9$) a< pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*): Mask to avoid performing attention on padding pixel indices. spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`): Tensor containing the spatial dimensions (height, width) of the input images. 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/siglip2-base-patch16-224") >>> processor = AutoProcessor.from_pretrained("google/siglip2-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' ``` Nr)rrrrrrgrdT)pdimkeepdimr)rer)losslogits_per_imagelogits_per_text text_embeds image_embedstext_model_outputvision_model_output)rQrrr text_modelrnormrpmatmultrure logit_scale logit_biasexpeyerk ones_likerV functional logsigmoidsummeanrL)r.rrrr`rrrrrr text_outputsrrrrrrrrm1_diag1logliknlls r$rSiglip2Model.forwards`2C1N-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 6 'tn 6   6v15487;591537&*,0/3e E,,-e u001e 'u||4 e !!1!12 e !. e u//0e d^e $D>e 'tne  e e r#rc\rSrSrS S\\R S\\R S\\RS\\R S\\S\\S \ 4S jjr S r g) Siglip2ForImageClassificationi Nrrr`labelsrrrbc4UbUOURRnUbUOURRnURUUUUUS9nURnUbLUSR UR 5n [R"X-SS9[R"U SS9- nO[R"USS9nURU5n Sn UGbUR U R 5nURRcURS:XaSURl OoURS:aNUR[R:XdUR[R:XaSURl OSURl URRS:XaI[!5n URS:Xa&U "U R#5UR#55n OU "X5n OURRS:Xa=[%5n U "U R'S UR5UR'S 55n O,URRS:Xa[)5n U "X5n [+U U UR,UR.S 9$) a pixel_attention_mask (`torch.Tensor` of shape `(batch_size, image_size, image_size)`, *optional*): Mask to avoid performing attention on padding pixel indices. spatial_shapes (`torch.LongTensor` of shape `(batch_size, 2)`): Tensor containing the spatial dimensions (height, width) of the input images. 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, Siglip2ForImageClassification >>> 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 `Siglip2Model` 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/siglip2-base-patch16-224") >>> model = Siglip2ForImageClassification.from_pretrained("google/siglip2-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)rr`rr).Nrhr regressionsingle_label_classificationmulti_label_classificationrd)rlogitsrr)rQrrrrrurerprr classifier problem_type num_labelsrflongrYrsqueezerviewrr rr) r.rrr`rrroutputssequence_output pool_maskrrloss_fcts r$r%Siglip2ForImageClassification.forward s2Z2C1N-TXT_T_TqTq$8$D $++JjJj /3.?.? /)/!5 /@/ "33 +,Y7::?;Q;QRI#ii(CKeiiXaghNiiO#jja@O1  YYv}}-F{{''/??a'/;DKK,__q(fllejj.HFLL\a\e\eLe/LDKK,/KDKK,{{''<7"9??a'#FNN$4fnn6FGD#F3D))-JJ+- B @&++b/R))-II,./$!//))   r#r)NNNNNN) rrr r!rrprrrr rr"rr#r$rr s047;59)-,0/3d u||,d 'u||4d !!1!12 d & d $D> d 'tnd  d d r#r)rCrr'rrrrr)/typingrrptorch.nnrVtorch.nn.functionalrrxrrr/transformers.models.siglip.configuration_sigliprrr *transformers.models.siglip.modeling_siglipr r r r rrrrrrrrrmodeling_attn_mask_utilsrrr'rCrFrIrLModulerOrrrrrrr__all__rr#r$r s AAnn C ( C,CL L  1  -  L bbiibJ0 60 f 2   "+N"0) *) X` ;` Ff $@f R r#