o eiu@s.ddlmZddlmZmZmZddlZddlmZddl m Z ddl m Z mZddlmZmZddlmZmZmZdd lmZmZdd lmZmZmZdd lmZmZm Z dd l!m"Z"m#Z#dd l$m%Z%ddl&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0ddl1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:ddl;mZ>m?Z?m@Z@ddlAmBZBe*CeDZEGddde0eZFGdddeZGGddde?ZHGddde<ZIGdddejJZKGd d!d!e4ZLGd"d#d#e7ZMGd$d%d%e8ZNGd&d'd'e2ZOGd(d)d)eZPdZQGd*d+d+e6ZRd,eSd-eeSeSeSeSgeTffd.d/ZUGd0d1d1e5ZVGd2d3d3e3ZWGd4d5d5ejXZYe,d6d7d8d9   : dOd;ed8ejZde dBd?ejZdBd@ejZdBdAej[dBdBeTdCeTdBd-e\fdDdEZ]GdFdGdGe>Z^GdHdIdIe=Z_GdJdKdKeRZ`GdLdMdMeeRZagdNZbdS)P)Callable)AnyLiteralOptionalN)initialization)Cache DynamicCache)PreTrainedConfiglayer_type_validation)create_causal_maskcreate_masks_for_generate!create_sliding_window_causal_mask) GenericForSequenceClassificationGradientCheckpointingLayer)BaseModelOutputWithPastBaseModelOutputWithPooling SequenceClassifierOutputWithPast)ROPE_INIT_FUNCTIONSRopeParametersdynamic_rope_update)ALL_ATTENTION_FUNCTIONSPreTrainedModel)Unpack)TransformersKwargsauto_docstringcan_return_tuplelogging)deprecate_kwarg)maybe_autocast) Gemma2Config) Gemma2AttentionGemma2ForCausalLM Gemma2MLP Gemma2ModelGemma2PreTrainedModel Gemma2RMSNormGemma2RotaryEmbeddingapply_rotary_pos_embeager_attention_forward)PaliGemmaCausalLMOutputWithPast!PaliGemmaForConditionalGenerationPaliGemmaModelPaligemmaModelOutputWithPasttoken_type_ids_mask_function)SiglipVisionConfigc4@s>eZdZdZdZdddZ                   d7dedBdedBdedBdedBdedBdedBdedBd edBd!edBd"edBd#edBd$e dBd%edBd&edBd'edBd(e dBd)edBd*edBd+edBd,e edBd-edBd.edBd/e e d0e fdBd1e dBd2e dBf2d3d4Zd8d5d6ZdS)9Gemma3TextConfigay This is the configuration class to store the configuration of a [`Gemma3TextModel`]. It is used to instantiate an Gemma3Text model according to the specified arguments, defining the model architecture. Instantiating a configuration with the defaults will yield a similar configuration to that of the Gemma3Text-7B. e.g. [google/gemma3_text-7b](https://huggingface.co/google/gemma3_text-7b) Configuration objects inherit from [`PreTrainedConfig`] and can be used to control the model outputs. Read the documentation from [`PreTrainedConfig`] for more information. Args: vocab_size (`int`, *optional*, defaults to 262208): Vocabulary size of the Gemma3Text model. Defines the number of different tokens that can be represented by the `inputs_ids` passed when calling [`Gemma3TextModel`] hidden_size (`int`, *optional*, defaults to 2304): Dimension of the hidden representations. intermediate_size (`int`, *optional*, defaults to 9216): Dimension of the MLP representations. num_hidden_layers (`int`, *optional*, defaults to 26): Number of hidden layers in the Transformer decoder. num_attention_heads (`int`, *optional*, defaults to 8): Number of attention heads for each attention layer in the Transformer decoder. num_key_value_heads (`int`, *optional*, defaults to 4): This is the number of key_value heads that should be used to implement Grouped Query Attention. If `num_key_value_heads=num_attention_heads`, the model will use Multi Head Attention (MHA), if `num_key_value_heads=1` the model will use Multi Query Attention (MQA) otherwise GQA is used. When converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed by meanpooling all the original heads within that group. For more details, check out [this paper](https://huggingface.co/papers/2305.13245). If it is not specified, will default to `num_attention_heads`. head_dim (`int`, *optional*, defaults to 256): The attention head dimension. hidden_activation (`str` or `function`, *optional*, defaults to `"gelu_pytorch_tanh"`): The non-linear activation function (function or string) in the decoder. Will default to `"gelu_pytorch_tanh"` if not specified. `"gelu_pytorch_tanh"` uses an approximation of the `"gelu"` activation function. max_position_embeddings (`int`, *optional*, defaults to 131072): The maximum sequence length that this model might ever be used with. initializer_range (`float`, *optional*, defaults to 0.02): The standard deviation of the truncated_normal_initializer for initializing all weight matrices. rms_norm_eps (`float`, *optional*, defaults to 1e-06): The epsilon used by the rms normalization layers. use_cache (`bool`, *optional*, defaults to `True`): Whether or not the model should return the last key/values attentions (not used by all models). Only relevant if `config.is_decoder=True`. pad_token_id (`int`, *optional*, defaults to 0): Padding token id. eos_token_id (`int`, *optional*, defaults to 1): End of stream token id. bos_token_id (`int`, *optional*, defaults to 2): Beginning of stream token id. attention_bias (`bool`, defaults to `False`, *optional*, defaults to `False`): Whether to use a bias in the query, key, value and output projection layers during self-attention. attention_dropout (`float`, *optional*, defaults to 0.0): The dropout ratio for the attention probabilities. query_pre_attn_scalar (`float`, *optional*, defaults to 256): Scaling factor used on the attention scores sliding_window (`int`, *optional*, defaults to 4096): In Gemma3Text, every other layer uses sliding window attention. This is the size of the sliding window. layer_types (`list`, *optional*): Attention pattern for each layer. final_logit_softcapping (`float`, *optional*): Scaling factor when applying tanh softcapping on the logits. attn_logit_softcapping (`float`, *optional*): Scaling factor when applying tanh softcapping on the attention scores. rope_parameters (`dict`, *optional*): Dictionary mapping attention patterns (`"full_attention"`, `"sliding_attention"`) to `RopeParameters`. Each value should be a dictionary containing `rope_type` and optional scaling parameters. use_bidirectional_attention (`bool`, *optional*, defaults to `False`): If True, the model will attend to all text tokens instead of using a causal mask. This does not change behavior for vision tokens. tie_word_embeddings (`bool`, *optional*, defaults to `True`): Whether to tie weight embeddings ```python >>> from transformers import Gemma3TextModel, Gemma3TextConfig >>> # Initializing a Gemma3Text gemma3_text-7b style configuration >>> configuration = Gemma3TextConfig() >>> # Initializing a model from the gemma3_text-7b style configuration >>> model = Gemma3TextModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` gemma3_textg.Ag@)globallocal@ $gelu_pytorch_tanh{Gz?ư>Trr FN vocab_size hidden_sizeintermediate_sizenum_hidden_layersnum_attention_headsnum_key_value_headshead_dimhidden_activationmax_position_embeddingsinitializer_range rms_norm_eps use_cache pad_token_id eos_token_id bos_token_idattention_biasattention_dropoutquery_pre_attn_scalarsliding_window layer_typesfinal_logit_softcappingattn_logit_softcappingrope_parametersfull_attentionsliding_attentionuse_bidirectional_attentiontie_word_embeddingsc s| _|_|_|_|_| _|_|_|_|_ |_ |_ | _ | _ | _|_|_|_|_|_|_|_|_|_|rRjdd_|dd_jdurkfddtjD_tjj|_tjdi|dS)Nr r@sliding_window_patterncs&g|]}t|djrdndqS)r@r\r[)bool_sliding_window_pattern).0iselfg/home/ubuntu/transcripts/venv/lib/python3.10/site-packages/transformers/models/gemma3/modular_gemma3.py sz-Gemma3TextConfig.__init__..rg)rOrQrPr^rCrKrDrErFrGrIrHrLrMrNrRrSrJrTrUrWrXrVr]getrbranger rYr __init__)rfrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrXrYr]r^kwargsrgrerhrlsD  zGemma3TextConfig.__init__cKs|dd}ddiddid}|jdur|jn||_|dur&|jd||jddur5ddi|jd<|jdd|d|jd|jddurTddi|jd<|jdd|d |jd ||j|d |S) N rope_scaling rope_typedefault)r\r[r[ rope_thetar3r\rope_local_base_freqr4) ignore_keys)poprYupdaterj setdefault default_thetastandardize_rope_params validate_rope)rfignore_keys_at_rope_validationrmrndefault_rope_paramsrgrgrhconvert_rope_params_to_dicts(    z,Gemma3TextConfig.convert_rope_params_to_dict)r5r6r7r8r9r:r;r<r=r>r?Trr@r FrAr;rBNNNNFTN)__name__ __module__ __qualname____doc__ model_typerwintstrfloatralistdictrrrlr|rgrgrgrhr1>sR        Fr1cseZdZdZdZddddZeedZ   ddee e e fBdBdee e e fBdBde dBde dBde dBde dBde dBdedBffdd ZZS) Gemma3Configa This is the configuration class to store the configuration of a [`Gemma3ForConditionalGeneration`]. It is used to instantiate an Gemma3ForConditionalGeneration according to the specified arguments, defining the model architecture. Instantiating a configuration with the defaults will yield a similar configuration to that of the PaliGemma-2B. e.g. [google/gemma-3-4b](https://huggingface.co/google/gemma-3-4b) Configuration objects inherit from [`PreTrainedConfig`] and can be used to control the model outputs. Read the documentation from [`PreTrainedConfig`] for more information. Args: text_config (`Union[Gemma3TextConfig, dict]`, *optional*): The config object of the text backbone. vision_config (`Union[AutoConfig, dict]`, *optional*): Custom vision config or dict. mm_tokens_per_image (`int`, *optional*, defaults to 256): The number of tokens per image embedding. boi_token_index (`int`, *optional*, defaults to 255999): The begin-of-image token index to wrap the image prompt. eoi_token_index (`int`, *optional*, defaults to 256000): The end-of-image token index to wrap the image prompt. image_token_index (`int`, *optional*, defaults to 262144): The image token index to encode the image prompt. initializer_range (`float`, *optional*, defaults to 0.02): The standard deviation of the truncated_normal_initializer for initializing all weight matrices. tie_word_embeddings (`bool`, *optional*, defaults to `True`): Whether to tie weight embeddings Example: ```python >>> from transformers import Gemma3ForConditionalGeneration, Gemma3Config, SiglipVisionConfig, Gemma3TextConfig >>> # Initializing a Siglip-like vision config >>> vision_config = SiglipVisionConfig() >>> # Initializing a Gemma3 Text config >>> text_config = Gemma3TextConfig() >>> # Initializing a Gemma3 gemma-3-4b style configuration >>> configuration = Gemma3Config(vision_config, text_config) >>> # Initializing a model from the gemma-3-4b style configuration >>> model = Gemma3TextConfig(configuration) >>> # Accessing the model configuration >>> configuration = model.config ```gemma3image_token_indexboi_token_indexeoi_token_index)image_token_id boi_token_id eoi_token_id) text_config vision_configNr;r>Trrmm_tokens_per_imagerLr^c  s|dur t}tdn t|trtdi|}t|tr&tdi|}n |dur2t}td||_||_||_||_ ||_ ||_ ||_ ||_ tjdi| dS)Nz@text_config is None, using default Gemma3TextConfig text config.zFvision_config is None, using default SiglipVisionConfig vision config.rg)r1loggerinfo isinstancerr0rrrrrrrLr^superrl) rfrrrrrrrLr^rm __class__rgrhrl6s&     zGemma3Config.__init__)NNr;rrrr>T)r~rrrr attribute_mapr1r0 sub_configsrrrrrrarl __classcell__rgrgrrhrsF1 rc@ eZdZdS)Gemma3ModelOutputWithPastNr~rrrgrgrgrhrZrc@r)Gemma3CausalLMOutputWithPastNrrgrgrgrhr^rrc sHeZdZdZd dedededeffdd Zd ejffd d Z Z S) Gemma3TextScaledWordEmbeddingz\ This module overrides nn.Embeddings' forward by multiplying with embeddings scale. ?num_embeddings embedding_dim padding_idx embed_scalecs0t|||||_|jdt|dddS)NrF persistent)rrlscalar_embed_scaleregister_buffertorchtensor)rfrrrrrrgrhrlgsz&Gemma3TextScaledWordEmbedding.__init__ input_idscst||j|jjSr})rforwardrtoweightdtype)rfrrrgrhrlsz%Gemma3TextScaledWordEmbedding.forward)r) r~rrrrrrlrTensorrrrgrgrrhrbs rcs"eZdZdeffdd ZZS) Gemma3MLPconfigcst|dSr}rrlrfrrrgrhrlqzGemma3MLP.__init__)r~rrr1rlrrgrgrrhrpsrcs(eZdZddedeffdd ZZS) Gemma3RMSNormr?dimepscstj||ddS)Nrrr)rfrrrrgrhrlvszGemma3RMSNorm.__init__)r?)r~rrrrrlrrgrgrrhrus rc@sveZdZddefddZe    ddedBdeddedBdedBd e d e ff d d Z e edd dZdS)Gemma3RotaryEmbeddingNrcCstj|j|_|j|_||_tt|j |_ i|_ |j D]P}|jj |}|dur+q|d|j |<|j }|j |dkrCt |j |}||j||d\}}|j|d|dd|j|d|ddt||d|qdS) Nrorp layer_type _inv_freqFr_original_inv_freq_attention_scaling)nnModulerlrKmax_seq_len_cachedoriginal_max_seq_lenrrsetrVrorYcompute_default_rope_parametersrrclonesetattr)rfrdevicer rope_params rope_init_fn curr_inv_freqcurr_attention_scalingrgrgrhrl{s&   zGemma3RotaryEmbedding.__init__rz torch.deviceseq_lenrreturnz torch.TensorcCs^|j|d}t|ddp|j|j}d}d|tjd|dtjdj|tjd|}||fS) a| Computes the inverse frequencies according to the original RoPE implementation Args: config ([`~transformers.PreTrainedConfig`]): The model configuration. device (`torch.device`): The device to use for initialization of the inverse frequencies. seq_len (`int`, *optional*): The current sequence length. Unused for this type of RoPE. layer_type (`str`, *optional*): The current layer type if the model has different RoPE parameters per type. Should not be used unless `config.layer_types is not None` Returns: Tuple of (`torch.Tensor`, `float`), containing the inverse frequencies for the RoPE embeddings and the post-processing scaling factor applied to the computed cos/sin (unused in this type of RoPE). rqrINrrr rrr) rYgetattrrDrGrarangeint64rr)rrrrbaserattention_factorinv_freqrgrgrhrs&z5Gemma3RotaryEmbedding.compute_default_rope_parametersc Cst||d}t||d}|ddddf|jddd|j}|dddddf}t|jjtrE|jjdkrE|jjnd}t |dd )|| dd } t j | | fdd } | |} | |} Wdn1sywY| j|jd | j|jd fS) Nrrrr@mpscpuF) device_typeenabledr rr)rrexpandshaperrrtyperr transposercatcossinr) rfx position_idsrrattention_scalinginv_freq_expandedposition_ids_expandedrfreqsembrrrgrgrhrs.& zGemma3RotaryEmbedding.forward)NNNNNNr})r~rrr1rl staticmethodrrrtuplerrrno_gradrrrgrgrgrhrzs*  #rcseZdZdedeffdd Z    ddejdejdejdBd edBd ej dBd e e d e ejejdBe ejdBffd dZ ZS)Gemma3Attentionr layer_idxcsdt|||jdkr|jnd|_|jdk|_|jj |_t|j |j d|_ t|j |j d|_ dS)Nr\r) rrlrrU is_slidingrr] is_causalrrIrMq_normk_normrfrrrrgrhrls   zGemma3Attention.__init__N hidden_statesposition_embeddingsattention_maskpast_key_valuescache_positionrmrcKs0|jdd}g|d|jR}|||dd} |||dd} |||dd} || } || } |\} } t | | | | \} } |dura| | |d}| | | |j |\} } t |jjt}||| | | |f|jrv|jnd|j|jd|\}}|jg|dR}||}||fS)Nrr@r )rrrrA)dropoutscalingrU)rrIq_projviewrk_projv_projrrr)rurr get_interfacer_attn_implementationr*trainingrSrrUreshape contiguouso_proj)rfrrrrrrm input_shape hidden_shape query_states key_states value_statesrr cache_kwargsattention_interface attn_output attn_weightsrgrgrhrs>      zGemma3Attention.forwardr)r~rrr1rrlrrr LongTensorrrrrrrgrgrrhrs* rcseZdZdedeffdd Z     ddejdejdejdBd ejdBd e dBd ejdBd e e d e ej e ej ej fdBffddZZS)Gemma3DecoderLayerrrcst||_|j|_||_|j||_t||d|_t ||_ t |j|j d|_ t |j|j d|_t |j|j d|_t |j|j d|_dS)N)rrr)rrlrrDrrVattention_typer self_attnrmlprrMinput_layernormpost_attention_layernormpre_feedforward_layernormpost_feedforward_layernormrrrgrhrls   zGemma3DecoderLayer.__init__Nrrrrrrrmrc Ksp|}||}|jd||||||d|\}} ||}||}|}||}||}||}||}|S)N)rrrrrrrg)rrrrrr) rfrrrrrrrmresidual_rgrgrhrs(     zGemma3DecoderLayer.forward)NNNNN)r~rrr1rrlrrrrrrr FloatTensorrrrgrgrrhrs0 rc@s,eZdZdZdZgdZeddZdS)Gemma3PreTrainedModelmodel)imagetext)rSiglipVisionEmbeddingsSiglipEncoderLayer#SiglipMultiheadAttentionPoolingHeadcCst||t|trt|jdSd|jjvr!t|j dSt|t r0t |j |j dSt|trm|jD]6}|j}|j|dkrKt|j|}||j|d\}}tt||d|tt||d|q8dSdS)NRMSNormrprrr)r _init_weightsrGemma3MultiModalProjectorinitzeros_mm_input_projection_weightrr~rr constant_rrrrVrrorrcopy_r)rfmodulerrrr rgrgrhr*Bs"      z#Gemma3PreTrainedModel._init_weightsN) r~rrbase_model_prefixinput_modalities_no_split_modulesrrr*rgrgrgrhr"8s r"rUrc s&dtdtdtdtdtf fdd }|S)zA Enables a bidirectional mask within the sliding window. batch_idxhead_idxq_idxkv_idxrcst||kS)zA token can attend to any other token if their absolute distance is within the (exclusive) sliding window size (distance < sliding_window).)abs)r5r6r7r8rUrgrh inner_mask[sz1_bidirectional_window_overlay..inner_mask)rra)rUr;rgr:rh_bidirectional_window_overlayVs"r<cseZdZUeed<dZdeffdd Z       ddejdBdej dBdejdBd e dBd ej dBd e dBd ejdBd e edefddZZS)Gemma3TextModelrr%cs0t|t|j|j|j|jjdd|_dS)N?)r)rrlrrCrDrr embed_tokensrrrgrhrlgs  zGemma3TextModel.__init__Nrrrr inputs_embedsrNrrmrc Ksv|du|duAr td|dur||}|r!|dur!t|jd}|dur=|dur-|nd} tj| | |jd|jd}|durF| d}t |} t s||j|||||d} | } |jj rmdd| d <t|jj| d <td i| td i| d } |} i}|jjD] }|| ||||<q|jd|jjD]}|| f| |j||j|||d |} q|| } t| |d S)N:You must specify exactly one of input_ids or inputs_embeds)rrr@rrrArrrrcWstjdtjdS)NTr)rrra)argsrgrgrhsz)Gemma3TextModel.forward..or_mask_functionrZ)rrrrr)last_hidden_staterrg) ValueErrorr@r rget_seq_lengthrrrr unsqueezerrcopyr]r<rUr rrV rotary_emblayersrFrnormr)rfrrrrrArNrrmpast_seen_tokenscausal_mask_mapping mask_kwargssliding_mask_kwargsrrr decoder_layerrgrgrhrosb          zGemma3TextModel.forward)NNNNNNN)r~rrr1__annotations__r3rlrrrrr!rarrrrrrgrgrrhr=cs<    r=cs,eZdZUeed<deffdd ZZS)Gemma3ForCausalLMrcst|t||_dSr})rrlr=r#rrrgrhrls zGemma3ForCausalLM.__init__)r~rrr1rUrlrrgrgrrhrVs rVcs2eZdZdeffdd ZdejfddZZS)r+rcsttt|jj|jj|_ t |jj|jj d|_ t |jj|jj|_t |jd|_|j|j|_tj|j|jd|_dS)Nrr?) kernel_sizestride)rrlr ParameterrzerosrrDrr.rlayer_norm_epsmm_soft_emb_normr image_size patch_sizepatches_per_imagertokens_per_siderW AvgPool2davg_poolrrrgrhrls  z"Gemma3MultiModalProjector.__init__vision_outputsc Csv|j\}}}|dd}||||j|j}|}||}|d}|dd}||}t ||j }| |S)Nr@r ) rrr r_r rbflattenr\rmatmulr.type_as) rfrc batch_sizer rDreshaped_vision_outputspooled_vision_outputsnormed_vision_outputsprojected_vision_outputsrgrgrhrs        z!Gemma3MultiModalProjector.forward) r~rrrrlrrrrrgrgrrhr+sr+ input_embedsz5.6.0rA)versionnew_nameFrrrrrtoken_type_ids pixel_values is_trainingis_first_iterationc Ks|r |dur td||||||d} | dur| n |dup&|j p&|du} |durh| rh|dk|j} tjj| dddddddf} | | @}tj | dd d}t | |d}t ||j|| d <t d i| S) a Overwrites the base `create_masks_for_generate` with `token_type_ids` masking to create the causal mask mapping for all kinds of forward passes. Gemma3 uses a bidirectional mask for images. Uses `pixel_values` as an optional input to disambiguate edge cases. Nz;`token_type_ids` is required as a model input when trainingrDr@)r@rr)valuerrrGrg)rIget_text_configis_initializedrrr functionalpadrcumsumrwherer/r )rrArrrrrorprqrrrmrRis_imageis_previous_imagenew_image_startimage_group_idsrgrgrhcreate_causal_mask_mappings.   "  r~cseZdZdZdeffdd Zeedddej de e d e e Bfd d Zee dd ejd Bdej d Bdejd Bdejd Bded Bdejd Bdejd Bdej d Bdejd Bded Bde e d e eBfddZZS) Gemma3ModelFrcst||`dSr})rrltext_config_dtyperrrgrhrl%s zGemma3Model.__init__zOProjects the last hidden state from the vision model into language model space.) custom_introrprmrcKs,|jd|dd|}|j}|||_|S)NT)rp return_dictrg) vision_towerrHmulti_modal_projector pooler_output)rfrprmrcrHrgrgrhget_image_features)s zGemma3Model.get_image_featuresNrrrrrorrAlabelsrN lm_kwargsc  KsV|du|duAr td|dur&|jj|jkr&||jjk} |} d| | <n|} |dur2|| }|durN|dur>|nd}tj|||j d|j d}|durp|j |ddj }| |j |j}|j|||d} || |}t|}tst|j||||||||jd }|jd ||||| d|d | }t|j|j|j|j|dur|d Sdd S) NrBrr@rCT)r)rAimage_features)rq)rrrrArNrr)rHrr attentionsimage_hidden_statesrg)rIrrrCrget_input_embeddingsrJrrrrrrrrget_placeholder_maskmasked_scatterrrr~rlanguage_modelrrHrrr)rfrrprrrrorrArrNrspecial_image_mask llm_input_idsrPrrQoutputsrgrgrhr4sj       zGemma3Model.forward) NNNNNNNNNN)r~rraccepts_loss_kwargsrrlrrrr!rrrrrrrrrarrrrgrgrrhr!sb      rcseZdZdZee           ddejdBdejdBdej dBdejdBde dBd ejdBd ejdBd ejdBd ejdBd e dBde ej Bde edeeBfddZ           dfdd ZZS)Gemma3ForConditionalGenerationFNrrrprrrrorrArrNlogits_to_keeprrc  Ks^|jd|||||||| | |d | } | d}t| tr"t| dn| }||dd|ddf}d}| dur|}|dddddf}| dddf}|dur~|dd|jd df|j}|||jdk }|||jdk }n| }| }t }| d|j jj}| d|j}|||}t||| j| j| j| jdS) a 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.text_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.text_config.vocab_size]`. Example: ```python >>> from PIL import Image >>> import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, Gemma3ForConditionalGeneration >>> model = Gemma3ForConditionalGeneration.from_pretrained("google/gemma-3-4b-it") >>> processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it") >>> messages = [ ... { ... "role": "system", ... "content": [ ... {"type": "text", "text": "You are a helpful assistant."} ... ] ... }, ... { ... "role": "user", "content": [ ... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, ... {"type": "text", "text": "Where is the cat standing?"}, ... ] ... }, ... ] >>> inputs = processor.apply_chat_template( ... messages, ... tokenize=True, ... return_dict=True, ... return_tensors="pt", ... add_generation_prompt=True ... ) >>> # Generate >>> generate_ids = model.generate(**inputs) >>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] "user\nYou are a helpful assistant.\n\n\n\n\n\nWhere is the cat standing?\nmodel\nBased on the image, the cat is standing in a snowy area, likely outdoors. It appears to" ``` ) rrprorrrrArNrrrN.rr@)losslogitsrrrrrg)r#rrslicelm_headrrrrr rCrossEntropyLossrrrrCrrrrr)rfrrprrrrorrArrNrrrr slice_indicesrr shift_logits shift_labelsshift_attention_maskloss_fct flat_logits flat_labelsrgrgrhrsP> $ z&Gemma3ForConditionalGeneration.forwardTc  s<tj|f|||||| | || d | }| s| s||d<|S)N) rrArrrrNrrorrrp)rprepare_inputs_for_generation)rfrrrArrrprrorNrrrrrm model_inputsrrgrhrs$ z 1` a classification loss is computed (Cross-Entropy). )rrprrrArorNNrr@z=Cannot handle batch sizes > 1 if no padding token is defined.rrz will not detect padding tokens in `inputs_embeds`. Results may be unexpected if using padding tokens in conjunction with `inputs_embeds.`rC)rr pooled_logitsr)rrrrr)r#rHrrrrrOrIrrrint32rargmaxr warning_oncerr~ loss_functionrrrr)rfrrprrrrArorrNrmtransformer_outputsrrrglast_non_pad_token non_pad_mask token_indicesrrrgrgrhr7sR     z'Gemma3ForSequenceClassification.forward) NNNNNNNNN)r~rr_checkpoint_conversion_mappingrlrrrrrrr!rrrarrrrrrgrgrrhr!sT      rc@seZdZUdZeed<dZdS)#Gemma3TextForSequenceClassificationz Gemma3TextForSequenceClassification is a text-only sequence classification model that works with Gemma3TextConfig. It uses the generic sequence classification implementation for efficiency and consistency. rr>N)r~rrrr1rUr3rgrgrgrhrs r) rr1r"r=rVrrrr)NNFN)ccollections.abcrtypingrrrrtorch.nnrrr, cache_utilsrr configuration_utilsr r masking_utilsr r rmodeling_layersrrmodeling_outputsrrrmodeling_rope_utilsrrrmodeling_utilsrrprocessing_utilsrutilsrrrrutils.deprecationr utils.genericrgemma2.configuration_gemma2r!gemma2.modeling_gemma2r"r#r$r%r&r'r(r)r*paligemma.modeling_paligemmar+r,r-r.r/siglipr0 get_loggerr~rr1rrr EmbeddingrrrrrrGEMMA3_START_DOCSTRINGr"rrar<r=rVrr+rr!rr~rrrr__all__rgrgrgrhs       ,  <aP:1" Y $   8b^