*j* UddlmZddlZddlZddlmZmZddlmZddl m Z ddl m Z m Z mZmZmZmZddlZddlmZddlmZdd lmZdd lmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3dd lm4Z5dd l6m7Z7dd l6m8Z9ddl:m;Z;ddlm?Z?ddl@mAZAmBZBddlCmDZDmEZEmFZFddlGmHZHmIZImJZJmKZKmLZLddlMmNZNddlOmPZPddlQmRZR ddl mSZSn#eT$r ddl>mSZSYnwxYw ddlmUZUn#eT$rGddZUYnwxYw ddlmVZVmWZWn%#eT$rGddZVGddZWYnwxYw dd lmXZXn#eT$rGd!d"ZXYnwxYw dd#lmYZYn#eT$rGd$d%ZYYnwxYw dd&lmZZZn#eT$rGd'd(ZZYnwxYw dd)lm[Z[n#eT$rGd*d+Z[YnwxYwe re;rdd,l\m]Z]e9j^e_Z`ee5ed-kZaee5ed.kZbee5ed/kZcee5ed0kZdeehd1Zfd2Zged3ZhGd4d5eZiGd6d7eid89ZjekeJejfZldd>Zmeeeedd?Znd@eodA< ddBlmpZpependC<n #eT$rYnwxYwdDdEdFdGidHfdDdEdIdGidJfdDdEdIdGidKfdDdEdIdGidKfdDdEdIdGidHfdEdLdGdEdLdGdMdHfd3ZqdNeodO<e0dPdQfe'dPdRfe2dPdSfe1dPdTfe$dPdUfe.dPdVfe/dPdWfe dXdYfe!dZd[fe%d\d]fe(d^d_fe)d`dafeYdbdcfe3dddefe&dfdgfeWdhdifgZrdjeodk<dEdFdGdEdFdGdldHd8fZsdmeodn<idodpdqdGdrdqdGdsdqdGdtdudvfdwdpdFdGdrdFdGdMdHdvfdxdpdFdGdydFdGdMdHdvfdzdpdqdGdrdqdGdMdHdvfd{dEdFdGdEdFdGd|dHd8fd}dEdFdGdEdFdGd|dHd8fd~ddEdFdGidHd8fdddEdFdGidHd8fdddEdFdGidHd8fdddEdFdGidHd8fddEdFdGdEdFdGddHd8fddEdFdGdEdFdGdEdFdGdtdHd8fdesdesdesdesdesesesesesesesdZtdeod<dddEdIdGidHd8fiZudeod<dEdIdGdEdIdGd|dKd8fdDdEdIdGidKd8fdZvdEdIdGdEdIdGd|dKd8fddEdIdGidKd8fddEdIdGidKd8fddEdIdGidKd8fddEdIdGidKd8fdEdIdGdEdIdGdldKd8fdZweteveweudZxdeod<ddZyedZzGdded89Z{GddeZ|hdZ}deod<dZ~deod<ddZddZeehdZeehdZGddeNZdS)) annotationsN)CallableSequence)contextmanager)fields) TYPE_CHECKINGAnyLiteral TypedDictget_argsget_type_hints)parse) Lowercase)r) AutoConfig AutoModelAutoModelForCausalLMAutoModelForMaskedLM"AutoModelForSequenceClassification AutoProcessorBlenderbotConfigBlenderbotSmallConfigFeatureExtractionMixinImageProcessingMixin LongT5Config M2M100Config MarianConfig MT5Config PegasusConfigPegasusXConfigPretrainedConfigPreTrainedModelPreTrainedTokenizerBaseProcessorMixinProphetNetConfigSwitchTransformersConfigT5Config UdopConfig UMT5Config WhisperConfig) __version__) ModelOutput)logging)is_peft_available)find_adapter_config_file) NotRequired)load_onnx_modelload_openvino_model)InputFormatterformat_modality raise_unsupported_modality_error)MODALITY_TO_PROCESSOR_ARG MessageInputModality PairInput SingleInput) InputModule)transformer_kwargs_decorator)suggest_extra_on_exception)Self)BaseVideoProcessorceZdZdS)r>N__name__ __module__ __qualname__\C:\Projects\DSCons\.venv\Lib\site-packages\sentence_transformers\base\modules\transformer.pyr>r>G rEr>)T5Gemma2ConfigT5Gemma2TextConfigceZdZdS)rHNr@rDrErFrHrHOrGrErHceZdZdS)rINr@rDrErFrIrIRrGrErI) T5GemmaConfigceZdZdS)rLNr@rDrErFrLrLZrGrErL)MoonshineConfigceZdZdS)rNNr@rDrErFrNrNbrGrErN)TimmWrapperConfigceZdZdS)rPNr@rDrErFrPrPjrGrErP)PaliGemmaProcessorceZdZdS)rRNr@rDrErFrRrRrrGrErR PeftConfigz4.56.1z 5.4.0.dev04.56.25.2.0>padding max_length truncationreturn_tensors)feature-extractionsequence-classificationtext-generation any-to-any fill-mask retrievalc$eZdZUded<ded<dS)_ModalityParamsRequiredstrmethod str | Nonemethod_output_nameN)rArBrC__annotations__rDrErFrdrds'KKK""""""rErdceZdZUdZded<dS)ModalityParamsa Parameters for a single modality entry in the modality config. The ``format`` key is only used for the ``"message"`` modality and controls how message content is structured: ``"structured"`` (list of typed dicts) or ``"flat"`` (direct string value). zLiteral['structured', 'flat']formatNrArBrC__doc__rirDrErFrkrks**)))))rErkF)totalconfigPretrainedConfig | PeftConfigreturntype[PreTrainedModel]c ddlm}|t|S#ttf$rYnwxYwt |dd}|r!t tj|Sddl }t |ddpgD]}t ||d}||cSdt |ddpivrtStdt |d dd ) a:Resolve the concrete ``*ForRetrieval`` class (ColPali, ColQwen2, ...) for ``transformer_task="retrieval"``. transformers (as of v5.13) has no ``AutoModelForRetrieval``, and ``MODEL_FOR_RETRIEVAL_MAPPING`` is incomplete (missing ``colqwen2``), so fall back to the checkpoint's ``architectures`` entry. r)MODEL_FOR_RETRIEVAL_MAPPINGbase_model_name_or_pathN architecturesrauto_mapz9Could not resolve a retrieval model class for model_type model_typezt. The transformer_task="retrieval" expects a `*ForRetrieval` architecture, e.g. ColPali, ColQwen2 or ColModernVBert.) &transformers.models.auto.modeling_autorutype ImportErrorKeyErrorgetattr_resolve_retrieval_model_classrfrom_pretrained transformersr ValueError)rprurvr architecture model_classs rFrrs5  VVVVVV*4<<88  "     &f.GNNc-j.HI`.a.abbb>>D" lL$??  "    # wvz488>B??  &GFT`bfDgDg & & &  s 11)r]r^r_rarbzdict[TransformerTask, Any]TRANSFORMER_TASK_TO_AUTO_MODEL)AutoModelForMultimodalLMr`textforwardlast_hidden_staterfrhtoken_embeddingslogitsscores causal_logits embeddings)rimagez1dict[TransformerTask, tuple[ModalityConfig, str]]TRANSFORMER_TASK_DEFAULTSrT5EncoderModelMT5EncoderModelUMT5EncoderModelUdopEncoderModelLongT5EncoderModelProphetNetEncoderSwitchTransformersEncoderModelz2transformers.models.blenderbot.modeling_blenderbotBlenderbotEncoderz>transformers.models.blenderbot_small.modeling_blenderbot_smallBlenderbotSmallEncoderz,transformers.models.m2m_100.modeling_m2m_100 M2M100Encoderz,transformers.models.pegasus.modeling_pegasusPegasusEncoderz0transformers.models.pegasus_x.modeling_pegasus_xPegasusXEncoderz0transformers.models.moonshine.modeling_moonshineMoonshineEncoderz,transformers.models.whisper.modeling_whisperWhisperEncoderz*transformers.models.marian.modeling_marian MarianEncoderz.transformers.models.t5gemma2.modeling_t5gemma2T5Gemma2Encoderzlist[tuple[type, str, str]]_ENCODER_ONLY_MODELS)audiorrz tuple[ModalityConfig, str, bool]_AUDIO_MODALITY_CONFIGblipget_text_features pooler_outputget_image_featuresget_multimodal_features)rrrrsentence_embeddingTblip-2sam3get_vision_featuresflavagit)rr visual_bertkosmos-2rzgrounding-dino paligemmavilt layoutlmv3)rrideficshubert moonshinesewzsew-dz unispeech-sat) unispeechwav2vec2zwav2vec2-conformerwavlmwhispervoxtral_realtimez+dict[str, tuple[ModalityConfig, str, bool]]_FEATURE_EXTRACTION_EDGE_CASESrr_FILL_MASK_EDGE_CASES)rr)rrrrrr)r]r_r`raz6dict[str, dict[str, tuple[ModalityConfig, str, bool]]]_EDGE_CASE_MODALITY_CONFIGSboolc|dSt|trdSt|trtd|DSdS)zVCheck whether a tokenizers normalizer (or sequence of normalizers) includes Lowercase.NFTc3@K|]}t|tVdSN) isinstancer).0ns rF z!_has_lowercase..s,@@:a++@@@@@@rE)rrNormalizerSequenceany) normalizers rF_has_lowercasersZu*i((t*011A@@Z@@@@@@ 5rEc+>Kfd|D} |D]\}}t||dV|D]\}}t||dS#|D]\}}t||wxYw)Nc4i|]}|t|dSrr~)rnameclss rF z-set_temporary_class_attrs..s'FFFDwsD$//FFFrE)itemssetattr)r overrides originalsrvalues` rFset_temporary_class_attrsrsFFFFIFFFI&$??,, & &KD% Cu % % % % $??,, & &KD% Cu % % % % & &9??,, & &KD% Cu % % % % &s /A//-BcPeZdZUdZded<ded<ded<ded<ded<ded<d S) ProcessingKwargsa|Keyword arguments applied when *calling* the processor during preprocessing. Valid keys: ``"common"``, ``"text"``, ``"audio"``, ``"image"``, ``"video"``, ``"chat_template"``. Modality and ``"common"`` kwargs override built-in defaults. ``"chat_template"`` kwargs are forwarded to ``apply_chat_template``, except the Sentence Transformers ``restore_suffix`` flag. dict[str, Any]commonrrrvideo chat_templateNrmrDrErFrrsf!!!!!!rErc<eZdZUdZded<ded<ded<ded <d S) QueryExpansionConfiga ColBERT-style query expansion config. When set, :meth:`Transformer.preprocess` expands every ``task="query"`` batch, regardless of the downstream modules: only meaningful with a :class:`MultiVectorMask` downstream (which scores the expansion positions), so leave it ``None`` for dense / sparse / cross-encoder pipelines. Keys: * ``strategy``: - ``"fixed"`` (classic ColBERT): every query leaves preprocessing at exactly ``length`` tokens. Shorter queries are padded up to ``length`` and the pads swapped for ``token`` (defaults to the tokenizer's ``mask_token``), longer queries are truncated down to it. ``length`` is both the floor and the ceiling: for query batches it overrides ``Transformer.query_length``. - ``"min"``: ``length`` is only the floor. Shorter queries are expanded exactly like ``"fixed"``, longer queries pass through untruncated instead of silently losing content. ``Transformer.query_length`` (or a trainer ``max_length`` override) still applies as the ceiling. On corpora where queries stay under ``length``, ``"min"`` and ``"fixed"`` produce identical batches. * ``attend``: whether the encoder attends to the expansion positions. ``False`` (default, classic ColBERT) leaves them at ``attention_mask=0``: the encoder skips them in the forward pass, MaxSim still scores them, and they soak up query context via the asymmetric attention mask. ``True`` forces ``attention_mask=1`` so the encoder also attends to them, matching PyLate's ``attend_to_expansion_tokens``. Used by some ColBERT variants. * ``token``: defaults to the tokenizer's ``mask_token``. * ``length``: pad target (total tokens after expansion, the width floor). **Required** (classic ColBERT uses 32). Query expansion exists for classic mask-token checkpoints (PyLate / Stanford-NLP ColBERT): their attention-mask surgery and fixed-length pad target cannot be expressed in a chat template. Modern chat-template backbones (the colpali-engine ColQwen / ColGemma / ColIdefics families) should instead own their query augmentation in the checkpoint's chat template, which receives the ``task`` kwarg and can e.g. append the family's suffix tokens for ``task == "query"`` renders. zLiteral['fixed', 'min']strategyzNotRequired[bool]attendzNotRequired[str | None]tokenzNotRequired[int]lengthNrmrDrErFrrsO##J&%%%""""rEr>rrrrset[str]_VALID_QUERY_EXPANSION_KEYS)fixedminztuple[str, ...]!_VALID_QUERY_EXPANSION_STRATEGIESquery_expansionQueryExpansionConfig | Nonec|dSt|tz }|r5tdt|dttd|d}|t vrtdt d|d|dd }t |tstd |d|d }|||d }|d }t |trt |ts|dkrtd|d||d <|S)zwValidate the dict, fill defaults, and return a fully-populated config (or ``None`` for the no-expansion case). Nz!query_expansion has unknown keys z. Valid keys: .rz+query_expansion['strategy'] must be one of z, got rFz.query_expansion['attend'] must be a bool, got r)rrrrquery_expansion strategy=zu requires 'length': a positive int specifying the pad target (total tokens after expansion). Classic ColBERT uses 32.) setrrsortedgetrrrint)runknownrrr normalizedrs rF_normalize_query_expansionr2s t/""%@@G  Dw D D!"=>> D D D   "":..H888 r:[ r rem r r r    5 1 1F fd # #WU&UUUVVV    ( (E4<Y^'_'_J   * *F fc " " j&>&> &1** V V V V   "Jx rEmessageslist[list[dict[str, Any]]]tuple[list[int], list[int]]chg}g}|D]}d}d}|D]u}|dg}t|ts.|D]D}t|tr-|dd} | dkr|dz }9| dkr|dz }Ev||||||fS)a}Count images and videos per sample from the message structure. Some VLM processors flatten per-sample visual tokens into single tensors (e.g. ``pixel_values`` shape ``(total_visual_tokens, hidden_dim)``), losing the per-sample association. By counting before the processor call, we get reliable per-sample counts that downstream minibatching can use directly. rcontentr{rrr)rrlistdictappend) r num_images num_videossample_messages img_count vid_countmsgritem item_types rF_count_media_per_sampler TsJJ#%%  " ' 'Cggi,,Ggt,,  ' 'dD))' $ 4 4I G++!Q "g--!Q  ' )$$$)$$$$ z !!rE> taskmodality prompt_lengthoffset_mappingspecial_tokens_masknum_images_per_samplenum_videos_per_samplequery_expansion_positionsoverflow_to_sample_mapping> input_ids return_dict inputs_embedsattention_masktoken_type_idsceZdZUdZdZded<gdZded<dddd Zd ed <d Zd ed<hdZ ded<e dddddddddddddddddfd1Z e dd2Z e jdd4Z e dd5Zejdd6Zdd9Zdd:Zdd<Ze dd=Zejdd>Ze dd@Ze ddBZe ddDZe ddFZddGZddMZddNZ dddRZddVZdd[Zdd^Zdd`ZddaZ dddcZ!dddZ"ddeZ# dddhZ$ddiZ% dddlZ& dddpZ'ddrZ(ddsZ)ddtZ*ddvZ+e,ddyZ-dd{Z.dd}Z/ddZ0ddZ1ddZ2ddZ3e,ddZ4e,ddZ5d dddZ6e7 dddZ8e7 dddZ9e7 dd҈fd Z:e,ddZ;dԈfd ZS) TransformeraJ"Hugging Face AutoModel wrapper that handles loading, preprocessing, and inference. Loads the appropriate model class (e.g. BERT, RoBERTa, CLIP, Whisper) based on the model configuration and the specified ``transformer_task``. Supports text, image, audio, and video modalities depending on the underlying model. This module is typically the first module in a :class:`~sentence_transformers.sentence_transformer.model.SentenceTransformer`, :class:`~sentence_transformers.sparse_encoder.model.SparseEncoder`, or :class:`~sentence_transformers.cross_encoder.model.CrossEncoder` pipeline. Args: model_name_or_path (str): Hugging Face model name or path to a local model directory. transformer_task (str, optional): The task determining which ``AutoModel``-like class to load. Supported values: - ``"feature-extraction"`` (default): :class:`~transformers.AutoModel`, e.g. used by :class:`~sentence_transformers.sentence_transformer.model.SentenceTransformer`. - ``"sequence-classification"``: :class:`~transformers.AutoModelForSequenceClassification`, e.g. used by :class:`~sentence_transformers.cross_encoder.model.CrossEncoder`. - ``"text-generation"``: :class:`~transformers.AutoModelForCausalLM`, e.g. used by generative :class:`~sentence_transformers.cross_encoder.model.CrossEncoder` models. Sets the ``tokenizer`` padding_side to "left". - ``"any-to-any"``: :class:`~transformers.AutoModelForMultimodalLM`, e.g. used by multimodal generative :class:`~sentence_transformers.cross_encoder.model.CrossEncoder` models (requires transformers v5+). Sets the ``tokenizer`` padding_side to "left". - ``"fill-mask"``: :class:`~transformers.AutoModelForMaskedLM`, e.g. used by :class:`~sentence_transformers.sparse_encoder.model.SparseEncoder`. Defaults to ``"feature-extraction"``. model_kwargs (dict[str, Any], optional): Keyword arguments forwarded to ``AutoModel.from_pretrained`` when loading the model. Particularly useful options include: - ``torch_dtype``: Override the default ``torch.dtype`` and load the model under a specific dtype. Can be ``torch.float16``, ``torch.bfloat16``, ``torch.float32``, or ``"auto"`` to use the dtype from the model's ``config.json``. - ``attn_implementation``: The attention implementation to use. For example ``"eager"``, ``"sdpa"``, or ``"flash_attention_2"``. If you ``pip install kernels``, then ``"flash_attention_2"`` should work without having to install ``flash_attn``. It is frequently the fastest option. Defaults to ``"sdpa"`` when available (torch>=2.1.1). - ``device_map``: Controls how the model is placed across devices, e.g. ``"auto"`` for model parallelism, or a single device like ``"cuda:1"`` to load the backbone directly onto one GPU. - ``provider``: For ``backend="onnx"``, the ONNX execution provider (e.g. ``"CUDAExecutionProvider"``). - ``file_name``: For ``backend="onnx"`` or ``"openvino"``, the filename to load (e.g. for optimized or quantized models). - ``export``: For ``backend="onnx"`` or ``"openvino"``, whether to export the model to the backend format. Also set automatically if the exported file doesn't exist. See the `PreTrainedModel.from_pretrained `_ documentation for more details. Defaults to None. processor_kwargs (dict[str, Any], optional): Keyword arguments forwarded to ``AutoProcessor.from_pretrained`` when loading the processor/tokenizer. See the `AutoTokenizer.from_pretrained `_ documentation for more details. Defaults to None. config_kwargs (dict[str, Any], optional): Keyword arguments forwarded to ``AutoConfig.from_pretrained`` when loading the config. See the `AutoConfig.from_pretrained `_ documentation for more details. Defaults to None. processing_kwargs (dict[str, dict[str, Any]], optional): Keyword arguments applied when *calling* the processor during preprocessing. This is a nested dict whose keys are modality names (``"text"``, ``"audio"``, ``"image"``, ``"video"``), ``"common"`` for kwargs shared across all modalities, or ``"chat_template"`` for kwargs forwarded to ``apply_chat_template`` (e.g. ``{"add_generation_prompt": True}``). Modality and common kwargs override the built-in defaults. The ``"chat_template"`` dict also accepts ``"restore_suffix"`` (default ``True``), a Sentence Transformers flag: fixed tokens a chat template appends after the content (e.g. an assistant prefill) are restored when truncation drops them, so models that read the final token position keep working. Saved to and loaded from the model configuration file. Defaults to None. backend (str, optional): Backend used for model inference. Can be ``"torch"`` (default), ``"onnx"``, or ``"openvino"``. Defaults to ``"torch"``. modality_config (dict, optional): Custom modality configuration mapping modality names to method and output name dicts. When provided, ``module_output_name`` must also be set. The ``"message"`` modality entry may include a ``"format"`` key (``"structured"``, ``"flat"``, or ``"auto"``) to control how chat-template inputs are formatted. Defaults to None. module_output_name (str, optional): The name of the output feature this module creates (e.g. ``"token_embeddings"``, ``"scores"``). Required when ``modality_config`` is provided. Defaults to None. unpad_inputs (bool, optional): Controls whether text-only inputs are concatenated without padding for faster inference using flash attention's variable-length functions. Non-text inputs (images, audio, video) are always padded normally. If ``None`` (default), unpadding is enabled automatically when all prerequisites are met (flash attention with variable-length support, ``"torch"`` backend, and the ``"feature-extraction"`` or ``"fill-mask"`` task). Set to ``False`` to force padding, which is needed for architectures that don't support unpadded inputs (e.g. ``qwen2_vl``). Set to ``True`` to request unpadding explicitly. A warning is logged if the prerequisites are not met. Defaults to None. query_length (int, optional): Per-task text max-length applied when ``task="query"`` reaches :meth:`preprocess` (e.g. via :meth:`encode_query`). Content-cap only (truncation). ``None`` (default) falls back to the tokenizer's ``model_max_length``. Used by ColBERT-style retrieval to cap queries shorter than documents. Not the pad target: query expansion specifies its pad target via ``query_expansion["length"]``, which overrides this (a smaller ``query_length`` raises when the expansion is assigned). document_length (int, optional): Per-task text max-length applied when ``task="document"`` reaches :meth:`preprocess`. ``None`` (default) falls back to the tokenizer's ``model_max_length``. query_expansion (QueryExpansionConfig, optional): ColBERT-style query expansion config. See :class:`QueryExpansionConfig`. ``None`` (default) means no expansion. When set, every ``task="query"`` batch is expanded during preprocessing, so only set this with a :class:`MultiVectorMask` downstream (leave it ``None`` for dense / sparse / cross-encoder pipelines). max_seq_length (int, optional): Truncate any inputs longer than this value. Prefer setting ``model_max_length`` via ``processor_kwargs`` instead. Defaults to None. do_lower_case (bool, optional): If true, lowercases the input (independent of whether the model is cased or not). Rarely needed. Defaults to False. tokenizer_name_or_path (str, optional): Name or path of the tokenizer. When None, ``model_name_or_path`` is used. Deprecated. Defaults to None. sentence_bert_config.jsonreconfig_file_name)transformer_taskmodality_configmodule_output_nameprocessing_kwargs unpad_inputs query_lengthdocument_lengthrz list[str] config_keysN)r"r#rr_DEFAULT_CONFIG_VALUESTr save_in_root>rrrrrrr_VALID_PROCESSING_KWARGS_KEYSr]torchF)r model_kwargsprocessor_kwargs config_kwargsr backendrrr!r"r#rmax_seq_length do_lower_casetokenizer_name_or_pathmodel_name_or_pathrTransformerTaskr)dict[str, Any] | Noner*r+r ProcessingKwargs | Noner,$Literal['torch', 'onnx', 'openvino']rModalityConfig | Nonerrgr! bool | Noner" int | Noner#rrr-r.r/rrNonec > t|tvrN|dkrtdt d|dt t||_|i}|i}|i}|pi|_t|j|j z }|r3t d|dt|j d||_||_d|_i|_i|_i|_| |_| |_||||\}}|||d kr0d |vr,|jt3d |jDsd |_|j|||||fi||_|j}t;r*d dlm}tA||r|!}tEj#|j$}t|j%|_&d|_'t3d|j%(Ds|j&tRz|_'| d|vr||d<tU5tWj,||n|fi||_-dddn #1swxYwY|j.!d|vrSt_|j0dr>|j0j1dkr.te|j.j3|j0j1|j._3|r|j.j4r|j.j5j6}to|sltqg}tA|trr|t |z }n||:|ts||j.j5_6n/ ||j._n!#tv$r||j.j<_YnwxYw|jdvrGt_|j-dr d|j-_=t_|j-drd|j-j._=|!d|vr|d>dd}nd}t|j0j@||j-|_A|l||_B| t d| |_C|DD]7\}}tA|trd|vsd|vrt d|d|8n-|F|j|j-\|_B|_CtGd |jBt |jB|jA_H|:t d!|j-jIjJ|jj0_K| |_L| |_MdS)"Nr`zThe 'any-to-any' transformer task requires transformers v5+. Please upgrade transformers with `pip install transformers>=5.0.0`.zUnsupported transformer_task 'z'. Supported tasks are: z%Unknown keys in `processing_kwargs`: . Valid keys are: z. Unknown keys will be ignored. Did you mean to nest them under 'common' or a modality key ('text', 'audio', 'image', 'video')?Fr^ num_labelsc3@K|]}|dVdS)ForSequenceClassificationN)endswith)rarchs rFrz'Transformer.__init__..Hs/gg$4==)DEEggggggrErr PeftModelc3FK|]}|jtjjuVdSr)kindinspect Parameter VAR_KEYWORD)rps rFrz'Transformer.__init__.._s/jjq16W.::jjjjjjrEmodel_max_lengthmax_position_embeddingsr_r` padding_sideleft tokenizermessagerlauto)rymessage_format processorzLoading the Transformer module with a custom modality_config requires also providing module_output_name with the name of the output feature that this module should create, for example "token_embeddings" or "sentence_embedding".rfrhz"Invalid modality_config entry for zQ: each entry must be a dict with 'method' and 'method_output_name' keys, but got zActive modality config: zThe `tokenizer_name_or_path` argument is deprecated and will be removed in a future version. Please use the same path for the model and processor.)Nsuper__init__rr|rrkeysrr rr'loggerwarningrr,r.track_media_counts_prompt_length_mapping_method_signature_cache_chat_template_suffix_cacher"r# _load_config%_warn_on_unsupported_attention_configrwrr; _load_modelmodelr-peftrArget_base_modelrD signaturer parameters_declared_forward_paramsmodel_forward_paramsvalues_FORWARD_SAFETY_NET_KEYSr<rrrRrNhasattrrprIrrHis_fastbackend_tokenizerrrrrrAttributeErrorbasic_tokenizerrLrr2ryinput_formatterrrrrinfer_modalitiesdebugsupported_modalities __class__rAtokenizer_classr!r)selfr0rr)r*r+r r,rrr!r"r#rr-r.r/ unknown_keysrp is_peft_model forward_modelrAforward_signaturernew_normalizersrQ modality_keyparamsrqs rFrTzTransformer.__init__s*  #A A A<//!ZI1AII[_`~aDaDaFaF\G\GII 2B  L  #!   M3D3J4122T5WW   NNR RR#)$*L#M#MRRR     *"'&(#<>$AC(). $ 1 12Dg} ] ]  226:::  9 9 9M11$,ggRXRfggggg- !"F %T%  0&'=  T`       ? & & & & & &-33 ? - < < > > $-m.CDD(+,=,H(I(I%59!jjDUD`DgDgDiDijjjjj a(,(EH`(`D %  %* %#*:::DK)BCC;K72==25N3T[5X33/ U>)U!%!A!LJ)*55j+4;;-%j2DEE?+tJ/?/??OO'3+22:>>>FXYhFiFi8CU7D44)UUUGT6DDDU  $E E Et~~66 5.4+t~{33 ?8>(5  &9+G+G,Y7;;HfMMNN#N-{-nX\Xf     D !) N '9D #(7(=(=(?(?  $ f!&$//863I3IMaioMoMo$V\VVKQVVNp =A>&+D # # #&*&>&>&@&@D #}}T%<}5}}}rEc|jS)a@ColBERT-style query expansion config. See :class:`QueryExpansionConfig`. Validated and normalized on assignment, so re-setting after construction is safe:: model[0].query_expansion = {"strategy": "fixed", "attend": True, "length": 32} model[0].query_expansion = None # turn off )_query_expansionr}s rFrzTransformer.query_expansions $$rEcRt|}|Qt|dd@|||ds#|rt dt|dd}|*|(||dkrt d|d|dd||_dS) Nr_raFlashAttention-2 is incompatible with query_expansion attend=False. FA2 strips attention_mask=0 positions, so the [MASK] expansion tokens used by MaxSim never receive an attention update. Pass attn_implementation='sdpa' (preserves semantics) or set attend=True (changes semantics).r"rz query_length=z+ is smaller than query_expansion['length']=z. The expansion length is the query width floor, so a smaller query_length cap is contradictory. Drop query_length, raise it to at least the expansion length, or lower the expansion length.)rr~_validate_query_expansion_token_is_flash_attention_requestedrr)rsr expansionr"s rFrzTransformer.query_expansions.u55  WT7D%A%A%M  0 0 ; ; ;X& 4+M+M+O+O  >t^T::  \%=,QZ[cQdBdBd( ((YbckYl(((  !*rErrcJ|jdS|d}|d}|-|jj|jjtd|ddS|j|}|jj}|||kr*||jjkrtd|d|dnd d dSdS) a6Tokenizer-aware checks. The structural ``_normalize_query_expansion`` runs without the tokenizer, so this method catches the two silent-wrong-behavior cases that require it: * ``token=None`` falls back to ``mask_token_id``, then ``eos_token_id``. If the tokenizer has neither, the preprocess swap silently no-ops and the encoder sees raw pad tokens. * An explicit ``token`` that isn't in the tokenizer's vocabulary resolves to ``unk_token_id`` (or ``None``), silently inserting unk tokens at expansion positions. Nrrrz with token=None falls back to the tokenizer's mask_token, then its eos_token, but this tokenizer has neither. Set ``query_expansion={..., 'token': ''}`` explicitly.zquery_expansion token=z3 isn't in this tokenizer's vocabulary (resolves to r8 unk_token_idz). Check your model family's expected token: PaliGemma uses '', Qwen2/2.5/3/Omni use '<|endoftext|>', Gemma3 uses '', Idefics3 / ModernVBERT use ''.)rN mask_token_id eos_token_idrconvert_tokens_to_idsr unk_token)rsrrrtoken_idunk_ids rFrz+Transformer._validate_query_expansion_tokens > ! FZ('" =~+38S8[ YYYY F>77>>,  F 2 2u@X7X7XXXX ( 0ffnXXX !3 27X7XrEc||jdvscd|jvsZ|jdksOt|jddr0t d|jDrdS dd lm}dd l m }n+#t$rt d YdSwxYw|sdS||jj\^}}}}|dSt d |ddd|_|j|xjhdzc_||_dS)aDetermine whether text-only inputs can be flattened (concatenated without padding) for more efficient inference. When enabled, text-only inputs are concatenated into a single sequence and processed using flash attention's variable-length functions, eliminating padding overhead and significantly speeding up inference. Non-text inputs (images, audio, video) are always padded normally, even when this returns True. This requires: 1. The ``"feature-extraction"`` or ``"fill-mask"`` task. Position-reading model heads (e.g. ``AutoModelForSequenceClassification``, which pools specific positions) are incompatible with flattened inputs, but the masked language modelling head is strictly position-wise, so its logits stay correct on a flattened sequence. 2. The ``"text"`` modality must be supported by the model. 3. All modality call methods must be ``"forward"``. ``get_..._features`` methods apply heads that are incompatible with flattened inputs. 4. The ``"torch"`` backend with an attention-interface-compatible model. 5. Flash attention with variable-length function support. Note: Some architectures don't work with unpadded inputs (e.g. ``qwen2_vl``). Use ``unpad_inputs=False`` to disable this optimization for such models. Returns: bool: True if text-only inputs can be flattened for efficient inference. )r]rarr(is_backend_compatiblecdS)NFrDrDrErFz1Transformer._can_flatten_inputs..9srEc3.K|]}|ddkVdS)rfrNrD)rrzs rFrz2Transformer._can_flatten_inputs..:s,]]V6(#y0]]]]]]rEFr)DataCollatorWithFlattening)lazy_import_flash_attentionz~Consider upgrading to transformers >= 5.0.0 to skip padding for text-only inputs, which can significantly speed up processing.NzuUsing flattened inputs with flash attention variable-length functions to avoid padding overhead for text-only inputs.T)return_seq_idxreturn_flash_attn_kwargsreturn_position_ids>seq_idx max_length_k max_length_q cu_seq_lens_k cu_seq_lens_q)rrr,r~r_rrfrr+transformers.modeling_flash_attention_utilsrr|rVrorrp_attn_implementation data_collatorre_infer_flatten_position_offset_flatten_position_offset)rsrr_flash_varlen_fns rFrzTransformer._can_flatten_inputss4  !)L L LT111|w&&N74:'> NNPP']]t?S?Z?Z?\?\]]]]]'5  ? ? ? ? ? ? _ _ _ _ _ _ _    LL?   55  1133 5&A&A$+Bb&c&c# Oa!  "5  D   87%) $     $ 0  % %***  % %)-(K(K(M(M%ts0 A==$B%$B%rc|jD]]}t|dd}t|tr5tt|ddt jjr|dzcS^dS)N padding_idxposition_embeddingsrr)r_modulesr~rrr(nn Embedding)rsmodulers rFrz*Transformer._infer_flatten_position_offsetesj((** ' 'F!&->>K+s++ '  5t<P11 '#Q&&&qrEc|j |jjSt|jjdr|jj}n |jj}t|dr|jSdS)zThe maximum input sequence length. Reads from the tokenizer if available, otherwise falls back to ``max_position_embeddings`` from the model config.Nget_text_configrI)rNrHrhr_rprrI)rs text_configs rFr-zTransformer.max_seq_lengthqst > %>2 2 4:$&7 8 8 ,*+;;==KK*+K ; 9 : : 76 6trEc0|j||j_dSdS)zTSet the maximum input sequence length. Only effective when a tokenizer is available.N)rNrHrs rFr-zTransformer.max_seq_lengths$ > %.3DN + + + & %rEr!c|jS)z!The underlying transformer model.)r_r}s rF auto_modelzTransformer.auto_models zrEr c|jjS)z#The underlying model configuration.)r_rpr}s rFrpzTransformer.configsz  rElist[Modality]cNt|jS)z]The list of supported input modalities (e.g. ``"text"``, ``"image"``, ``("image", "text")``).)rrrUr}s rF modalitieszTransformer.modalitiess!D(--//000rEPreTrainedTokenizerBase | Nonecpt|jtr|jSt|jddS)zVThe tokenizer, extracted from the processor. Returns ``None`` for non-text processors.rNN)rrRr"r~r}s rFrNzTransformer.tokenizers5 dn&= > > "> !t~{D999rEc. ddlmn#t$rYdSwxYwt|jdd}||jt|jdd}t |tr|n|g}tfd|DS)a Whether the active chat template (the processor's, else the tokenizer's) uses a ``task`` variable, e.g. to append query augmentation tokens for ``task == "query"`` renders. Reuses the template introspection transformers' own kwarg routing is based on.r)_get_template_variablesTrNc3\K|]&}t|to d|vV'dS)r Nrre)rrrs rFrz;Transformer._chat_template_declares_task..sEnn[`:eS))Vf8O8OPU8V8V.VnnnnnnrE) &transformers.utils.chat_template_utilsrr|r~rRrNrrrfr)rstemplate templatesrs @rF_chat_template_declares_taskz(Transformer._chat_template_declares_tasks  V V V V V V V   44 4>?DAA   :t~EEH)3Hd)C)CSHOO%%%( nnnndmnnnnnns  r r7processor_inputskwargsr c |ddkr |jdS|jo+|dkp%|dko|j|dS)aWhether to pack variable-length text inputs into a single flat sequence (FA2 unpadding). Only safe for text-only inputs, since :class:`DataCollatorWithFlattening` only handles ``input_ids`` / ``labels``. Subclasses can override to opt out for specific tasks. r queryNFrrO)rrrrmis_text_only_messages)rsr rrs rF_should_flatten_inputsz"Transformer._should_flatten_inputssk ::f   ( (T-A-M5&   sI%q$*>*T*TUefoUp*q*q rEc ddlm}n#t$rYdSwxYwt|jdd}|dS||S)z[Whether the loaded model was configured for FlashAttention-2 (via ``attn_implementation``).r)is_flash_attention_requestedFrN)"requested_attention_implementation)transformers.utils.genericrr|r~rp)rsr attn_impls rFrz)Transformer._is_flash_attention_requestedsq  O O O O O O O   55 DK)?FF  5++yYYYYs  inputs!Sequence[SingleInput | PairInput]promptc |siSddi}dddddiiid}|jjdkr d |d d<|d }|d }||} n|d kr|j} n|dkr|j} nd } |d kr|jnd } | A| ddkr5|3|| dkr't d| dd|d| | | |dd <||} d| vr| | d|D]4} | | x} r||  | 5| | dpi}| ddkr?d|vsd |vrt d| d|dd <d |dd<nX| Vd |vrR| | dkr't d| dd| dt| | d|dd <| di}|| rd |i|}|j |\}}}|jdkr,|dkr&|$|d krt d|d|D] \} }||  |!|j||fi|}|r*|d=|ddd d|dd <d!|jvrF|d!kr@| |dkrt'd"| dd#|j ||\}}n?||jvr6t+||t-|jd$|d!kr||d!|d }|r+|d!kr%|j |d!||d!<n:|r8|dkr2|j |d||d<|j|fi|}d }d }|jr|d!krt;|d!\}}t=5||||||%d d d n #1swxYwY|'d&vr#tAj!|t@j"'d(<|'d)vr#tAj!|t@j"'d*<|rlfd+tG$D}|%|d,d |j&rd-|j&zd-<|d.<||d/<|jd0vr|'||d1d2<|d kr|jnd } | d3vrd4vr| d}d4}d3}|j(d1|kr||j(d1z }t@j)j*+|d5|fd56}t@j)j*+|d5|fd56}|d4<|d3<d7vr2t@j)j*+d7d5|fd56d7<|d5ktAj,|j(d1|j-8|kz}| ddkrF|.d9:/st d;|d<|j0^| d=!|j01| d=}n|j0j2}| |j0j3}||4||d4<|d><| d?r|4|d1d3<S)@aPreprocess inputs into model-ready features. Args: inputs: List of inputs. Can contain strings, dicts with modality keys, PIL images, or numpy/torch arrays for audio/video. prompt: Optional prompt to prepend to text inputs or inject as a system message. processing_kwargs: Per-call overrides for the processor kwargs configured on the module via the ``processing_kwargs`` constructor argument. Same nested structure (modality keys plus ``"common"`` and ``"chat_template"``). Per-call values are merged on top of the instance-level kwargs with shallow per-modality merge, so individual settings (e.g. only ``max_length``) can be overridden without replacing the entire modality dict. Defaults to None. **kwargs: Additional keyword arguments forwarded to prompt length computation (e.g. ``task``). Only used when ``prompt`` is provided for text inputs. Returns: Dictionary containing preprocessed tensors with a ``modality`` key indicating the input type and optionally a ``prompt_length`` key for prompt-aware pooling. r[ptT longest_firstrXrZrXrrrrrrYrr Nrdocumentrrrz!query_expansion fixes queries to z tokens, so the max_length=z' override is ignored for query batches.rrzprocessing_kwargs overrides the text padding or max_length, but query expansion requires a fixed width: re-applying padding='max_length' with the expansion length for query batches.z$query_expansion guarantees at least z! query tokens, so the max_length=z, override is raised to it for query batches.rrbzJThis retrieval model's processor always renders text as a query, but task=zw was requested: these inputs get the query prefix and augmentation tokens. *ForRetrieval models expect image documents.Freturn_attention_maskrOrad cannot be combined with a chat-template (message) backbone: queries are rendered through the chat template and then padded / truncated to the expansion length, which destroys the query content. Chat-template backbones should own their query augmentation in the template itself (it receives task='query'), or pin modality_config to the plain text modality.zTransformer modulechat_template_kwargsimage_grid_thw)dtypervideo_grid_thwrcJg|]}tt| SrD)rzip)rrfprocessor_outputs rF z*Transformer.preprocess..s,lll&$s#3V<<==lllrElabels position_idsr r rKrlogits_to_keeprrr)rrdevicerJdimz@One or more queries filled the entire query_expansion length of zk tokens: any content beyond it was truncated, as this model always processes queries at exactly this width.rrr)5rpryrr"r#rrV warning_once_merge_processing_kwargsupdatemaxrrm parse_inputsrrrpoprrbatch_to_messager4rrU_verify_pair_roles_supportedprepend_prompt_to_messagesprepend_prompt_to_texts_get_prompt_lengthrXr r<_call_processorr(tensorlongrrfrr_verify_left_paddingshaper functionalpadarangerrallrNrrr masked_fill) rsrrr r common_kwargsmodality_kwargsr max_length_overridetask_max_lengthreffective_processing_kwargsryrtext_overridesrr rextra_modality_kwargs extra_kwargsshould_flattenr rr per_samplefloorrrmissingexpansion_positions expansion_idrs @rF preprocesszTransformer.preprocesss7 4 I)40 $ODD&    ; !Y . .3?OG $Y / zz&!!$jj66  *1OO W__"/OO Z  "2OO"O-1GOOD((  !*%00#/#y':::   [Ih4G[[1[[[     &9+<4COF #L 1&*&C&CDU&V&V# 2 2 2  ! 9B(8K' 55A' 22 ,^1S1S"Yx%888''dy?Rdd&5ddd9>PRSS   A A C C $*D#I4H#I <@ > > > 54X?OZZSYZZ  E./ F # ' ' 4 8 8 8?DOF #$; < , , ,Y1F1F$V););!% *0E%%%*.)=)N)NxYi)j)j &H&& T1 1 1 ,VXtDDXD]D]D_D_?`?`bv w w w y  - -.>y.IK_ ` ` `  Fh)++*.*>*Y*Y +V++ Y ' '  FF**'+';'S'STdekTlnt'u'u V $3D3FEEfEEM !% $  " px9'<'<;RScdmSn;o;o 8 !#8 ' ) )  #33 %9 4                   ! ,1AEU1U1U8= EZbgbl8m8m8m 4 5 ,1AEU1U1U8= EZbgbl8m8m8m 4 5  tllllCQaQhQhQjQjLklllJ#11*==   4 0 0 0, t3CN3SVZVs3s 0'/$  $0= _ -  $E E E  % %&6 W W W12 - .-1GOOD((  %59I%I%Ik]mNmNmh'E(5I-.>?Nq!E)))/!"44!H/33I7|ST3UU !&!4!8!8!W]^!8!_!_09 -5C !12#'7779>9L9P9P()9:QLPQ:Q::$%56 $2Q#6 Y_Q/8MNNNQVV#  $//8K8O8OTV8O8W8W8[8[8]8]/##"W\""" ~)W%1#'>#G#G RYHZ#[#[LL$(>#?L#+'+~'B +4=4I4IJ]_k4l4l$[1|j|sdSd|D}|j|}|dSt |jddpd}|jjdkrd}nd}td|d |d |d ) aRaise if the chat template cannot carry the ``query``/``document`` roles a pair is mapped to. A template that only branches on ``system``/``user``/``assistant`` renders a pair to an empty prompt, so the model would score an input holding neither the query nor the document. Published rerankers ship a template that handles both roles, so this is reached when a backbone is used, or fine-tuned, without one. Nc8i|]\}}|tv|dk||S)restore_suffix%_APPLY_CHAT_TEMPLATE_TOP_LEVEL_KWARGSrkeyrs rFrz.s?   U???CK[D[D[ D[D[D[rE name_or_pathz this model structuredz : {{ (messages | selectattr("role", "eq", "query") | first).content[0].text }} : {{ (messages | selectattr("role", "eq", "document") | first).content[0].text }} z : {{ messages | selectattr("role", "eq", "query") | map(attribute="content") | first }} : {{ messages | selectattr("role", "eq", "document") | map(attribute="content") | first }} zThe chat template of z) cannot carry a 'query'/'document' pair (zi). Pair inputs are mapped to one message per role, so set a chat template that renders both roles, e.g.: zvia `processor_kwargs={"chat_template": ...}` when loading, `model.processor.chat_template = ...` afterwards, or a `chat_template.jinja` file alongside the model.)rmhas_pair_rolesrpair_roles_failurer~rprQr)rsr r probe_kwargsfailure model_nameexamples rFrz(Transformer._verify_pair_roles_supporteds#22>BB  F  288::   &99,GG ? FT[.$??O<   ., > >t G }  OJ O OY` O O O O O   rErrdict[str, dict[str, Any]]rc|d}t|tjr |jdkrdS|dddfrdSt d|dd|dfDd}|d|d }n"t|jd rd nd }d |d|d}td|z)aVerify that causal inputs are left-padded, i.e. that every sample ends in a real token. Checks the produced ``attention_mask`` rather than ``padding_side``, because the side that actually applies can come from the tokenizer attribute or from either the ``"text"`` or ``"common"`` processing_kwargs bucket, and which of those wins differs per processor type and per call path. The output is the only signal that covers every route. rNrJc3*K|]}||dk |VdS)NrMrD)rsides rFrz3Transformer._verify_left_padding.. s9  #(6  rErrLz3Your ``processing_kwargs`` set the padding side to z . Remove it or set it to "left".rNzprocessor.tokenizerrRzThe module sets ``zS.padding_side`` to "left" on load, so it was changed afterwards. Restore it with ``z.padding_side = "left"``.zAt least one sample ends in a padding token, but causal models require left padding so that the last token position is always a real token. This is needed for efficient logit computation (logits_to_keep=1) and for LogitScore. ) rrr(TensorndimrnextrhrRr)rsrrrr kwargs_sidefix padder_paths rFrz Transformer._verify_left_paddingsF*--.>??.%,77 >;NRS;S;S F !!!R% $ $ & &  F  ,V488HH-J[J[\jJkJkl         "w wwwCC3:4>;3W3Wh//]hKL[LL%0LLL  egj k   rEper_callrcD|s|jSt||jz }|r3td|dt |jdi}|jD]@}|j|i}||i}|s|r i||||<A|S)aMerge per-call ``processing_kwargs`` on top of the instance-level ``self.processing_kwargs``. The merge is shallow per top-level key: for each modality (or ``"common"`` / ``"chat_template"``), per-call entries override individual instance entries, leaving non-overridden settings intact. Unknown top-level keys in ``per_call`` are warned about and ignored. z.Unknown keys in per-call `processing_kwargs`: r:z. Unknown keys will be ignored.)r rr'rVrrr)rsr%rtmergedrinstance_valueper_call_values rFrz$Transformer._merge_processing_kwargs s *) )8}}t'II     ooo#)$*L#M#Mooo    $&5 C CC!377R@@N%\\#r22N C CBB>Bs  rEfeaturesc |dd}j|}|d}|d}t|tr|f}n$t|trt |}i||ddi}t j|d}|td|d |d krIj !fd | D} nfd | D} nlj |0ttj|jj |<fd | D} | d|vrd| d<|di| } | } |m|D]j} | | } #t t"f$rK t | | } n6#t$$r)t%d| dt'| jdwxYwYgwxYw| jdkr)| ddd} | |j<d|vrd|vrt3rddlm} tj| rrjjjra|djd}|d}t?j |jjj!|j"}t?j#||fd|d<tIjj%dr jj%j&rd| vr | d|d<|S)aForward pass through the transformer model. Dispatches to the appropriate model method based on the ``modality`` key in ``features`` and writes the result into ``features[self.module_output_name]``. Args: features: Input features dictionary produced by :meth:`preprocess`. Must contain the keys expected by the underlying model (e.g. ``input_ids``, ``pixel_values``, etc.). A ``modality`` key selects the modality config to use. Defaults to ``"text"`` when absent. **kwargs: Additional keyword arguments forwarded to the model method (override features). Returns: The updated ``features`` dict with the model output stored under ``self.module_output_name`` (e.g. ``token_embeddings``, ``sentence_embedding``, ``scores``, or ``causal_logits``). May also include ``all_layer_embeddings`` if ``output_hidden_states`` is enabled. r rrfrhrTNz#Model does not have the requested 'z' methodrc@i|]\}}|tvs |jv||SrD)_NON_MODEL_FEATURE_KEYSrdrrrrss rFrz'Transformer.forward..`sB###"U"999SDDa=a=a=a=a=arEc.i|]\}}|jv||SrD)rer.s rFrz'Transformer.forward..fs."w"w"w*#uVY]a]vVvVv3VvVvVvrEc$i|] \}}|v || SrDrD)rrr method_paramss rFrz'Transformer.forward..ls+gggjc5RUYfRfRfsERfRfRfrE hidden_statesoutput_hidden_stateszCould not access output key z% via indexing or attribute access on rrrrrrr@rrall_layer_embeddingsrD)'rrrrertupler~r_rrerrZrrDrbrcr} TypeErrorrkr{rAr flatten transposerr-r`rAactive_peft_configis_prompt_learningrr(onesnum_virtual_tokensrcatrhrpr3)rsr*r modality_namemodality_params method_namerh all_kwargs model_methodfiltered_kwargs model_output embedding output_keyrA batch_sizerprefix_attention_maskr1s` @rFrzTransformer.forward:s&#+,,z6"B"B .}=%h/ ,-AB (# . . ;"4!6   *D 1 1 ;!&'9!:!: A@F@M4@@ tz;==  X;XXXYY Y ) # #(0####&0&6&6&8&8### #x"w"w"w @P@P@R@R"w"w"w 8<<[IIM$ #G$5l$C$C$N O O :>>"&y//":>>>"  >Q  "))!,,66q!< > M !6 M <///;O/LH+ ,s*?FG$F+*G$+3GG$#G$ctjjtrjjjSjdkr,t jjddjjjSfd}|jjx}|Stjjdr|jjj x}|StjjdrQjjj D]-}t jj|}||x}|cS.tdtjjjd) aGet the output embedding dimension from the transformer model. Returns: int: The hidden dimension size of the model's embeddings. Raises: ValueError: If the embedding dimension cannot be determined from the model config. rb embedding_dimNc>t|drjdkr|jSt|dr|jSdD]H}t||r6t ||}t |t r |r |dcSD|cSIt|dr|jSdS)Nprojection_dimr hidden_size)neck_hidden_sizes hidden_sizes embed_dimsrJ hidden_dim)rhrrMrNr~rrrR)rp attr_namerrss rFget_hidden_size_from_configzHTransformer.get_embedding_dimension..get_hidden_size_from_configsv/00 -T5LPd5d5d,,v}-- *))P % % 69--%#FI66E!%..% -#(9,,,- % %v|,, )((4rEr sub_configszHCould not determine embedding dimension from model config. Config type: r)rr_rprP num_featuresrr~rKrhrrUrUrr{rA)rsrTrNsub_config_name sub_configs` rFget_embedding_dimensionz#Transformer.get_embedding_dimensions dj'): ; ; 2:$1 1  K / /GDJ#>z#J#JJKW&&&&X zW[\`\f\mWnWnWw z z z   rEdict[str, list]c|dkr||d|||St|jtr|||||S|||||S)anCall the appropriate processor with the correct arguments. Dispatches based on the processor type and modality: 1. **Message modality**: delegates to :meth:`_process_chat_messages`. 2. **Multi-modal processor** (:class:`ProcessorMixin`): delegates to :meth:`_call_multimodal_processor`, which handles both legacy (flat kwargs) and transformers v5 (per-modality kwargs) calling conventions. 3. **Single-modality processor** (tokenizer, feature extractor, image/video processor): delegates to :meth:`_call_single_modality_processor`, which matches the processor type and passes the primary input as a positional argument when available. Args: modality: The modality or tuple of modalities being processed. processor_inputs: Dictionary of processor argument names to lists of values. modality_kwargs: Per-modality configuration kwargs (keys: ``"text"``, ``"image"``, ``"audio"``, ``"video"``). common_kwargs: Common kwargs passed to all processor calls (e.g. ``padding``, ``return_tensors``). chat_template_kwargs: Kwargs forwarded to ``apply_chat_template`` when the modality is ``"message"``. Ignored for non-message modalities. Returns: Processor output dictionary. rOr)_process_chat_messagesrrRr#_call_multimodal_processor_call_single_modality_processor)rsr rrrrs rFrzTransformer._call_processorsB y .. +%9 /  dnn 5 5 o228=M`mnn n33H>NP_anooorEc |jdkr$d|vr ddlmi|dfd|dDi}d|D}|jjdvst s2|dkri|d |d }n||}|jd i|||S|jd i||d |d|d |d |d S)zZCall a :class:`ProcessorMixin` processor, handling both legacy and v5 calling conventions.rbrr) load_imagecTg|]$}t|tr |n|%SrDr)rrr`s rFrz:Transformer._call_multimodal_processor..sDOTE3)?)?JJJu%%%UrEc@i|]\}}tj|||SrD)r5rrs rFrz:Transformer._call_multimodal_processor..s-vvvzsTY59#sCCUvvvrE>rclipsegrrrrr text_kwargs images_kwargs audio_kwargs videos_kwargsrrD)rtransformers.image_utilsr`rrpry0_TRANSFORMERS_PROCESSOR_SUPPORTS_MODALITY_KWARGSrR)rsr rrrrr`s @rFr]z&Transformer._call_multimodal_processor sf  K / /G?O4O4O ; ; ; ; ; ; " XhipXq   wv]m]s]s]u]uvvv K "&D D DC E,,,POF3Pw7OP(2!4>PP$4PP-PP Pt~   '/)'2(1)'2'      rEcdt|dfdt|dfdt|dfdt|dfg}|D]]\}}}t |j|si||} ||vr'||} |j| fi|| cS|jd i|| cStdt|jj dt|d) zWCall a single-modality processor (tokenizer, feature extractor, image/video processor).rrrrz2Could not determine how to call processor of type z for modality ''NrD) r"rr>rrrRr RuntimeErrorr{rAr3) rsr rrrprocessor_type_checks modality_typeprocessor_class type_kwargs call_kwargs primary_inputs rFr^z+Transformer._call_single_modality_processor7sB,of.E F ,og.F G (/'*B C *OG,D E ! > :[:M:K 000 0 4 4] C C %t~mWW7GW;WWWWW!4>DD$4D DD D D D :dnAUAUA^ : :,X66 : : :   rErlist[list[MessageInput]]c d|jvr6tdt|jt |pi}|dd}|d}|d|d|d}|d|d|d}t|p|duo|du} |o| o|d k} |||||} | r#||j }| | |||||| S) aProcess chat messages using the processor's chat template. ``chat_template_kwargs`` is forwarded to ``apply_chat_template``, except the Sentence Transformers ``restore_suffix`` flag, which only toggles the truncation suffix restore. rOznThe model does not support 'message' modality, but the input looks like a chat message. Supported modalities: r TrrZrYNdo_not_truncate) rrrrUrrrr_apply_chat_templater-_restore_chat_template_suffix) rsrrrrr rerZrYtruncation_activerestore_chat_template_suffixr*s rFr\z"Transformer._process_chat_messagesXs D0 0 0M)-d.B.G.G.I.I)J)JMM  $$8$>B??.112BDII &f- )-- +//, 8I8I,8W8WXX  *-- +//, 8I8I,8W8WXX  !,,_t1C1^ Z^H^'5'o:K'oPZ^oPo$,,X Wkll ' !!0  . .($8+}V`   rEc  tzx}r/tfd|D}idid|it|jt r|j|j|rshd}fd|zD}|fd|dzDz}|jj |fddd|dSt|jtrtrd|jj |fdd d d  d d dd dd ddS|jj |fdddd dd dStd tfdtzD}| fdt zDz}|jj |fdd d|S)a>Call ``apply_chat_template`` with the kwarg routing the processor type expects: nested kwargs for a ProcessorMixin, flat with the size kwargs hoisted to the top level for a bare tokenizer. Both the real batch and the suffix skeleton renders go through this (the given dicts are never mutated). c<i|]}||SrDr)rrrs rFrz4Transformer._apply_chat_template..s*NNNSc/33C88NNNrErN>rXrYrZr[c<i|]}||SrDr}rrrs rFrz4Transformer._apply_chat_template..s)ttt]%6%6s%;%;tttrEcHi|]}|d|S)rr})rrrs rFrz4Transformer._apply_chat_template..s;!!!:=_V,0055!!!rET)tokenizerr[rload_audio_from_videoFrrrd)rrr[rr*)rrrerfrgrhrc<i|]}||SrDr}rs rFrz4Transformer._apply_chat_template..s6   ,/C""3''   rEc<i|]}||SrDr})rrres rFrz4Transformer._apply_chat_template..s4   *-C%%   rE)rrtokenizer_kwargsr) rrUrrrRrRrNrmrapply_chat_templater#=_TRANSFORMERS_APPLY_CHAT_TEMPLATE_RECOMMENDS_PROCESSOR_KWARGSr) rsrrrr size_keysfoldedtop_level_kwarg_namestop_level_kwargsres ``` @rFrwz Transformer._apply_chat_templatesw>@T@Y@Y@[@[[ [9 a#'(<#=#= NNNNINNNF``&:__V=T:_X^:_``O t~'9 : : *$::8DD+%^$]$] !ttttG\_l_q_q_s_sGsttt  !!!!AVYhioYpYuYuYwYwAw!!!  64>5 #  "&)  '   dnn 5 5 M 9t~9! $#0#4#45E#F#F*9'*B*F*FG^`e*f*f'6v'>)8)A(7(@)8)A)6 && +64>5  +F3-g6,W5-g6+  '   ?6233 ]++     3X[h[m[m[o[o3o        1VYdYiYiYkYk1k    2t~1  ('     #   rErrYc|d}t|tjtfsdS|pd}t|tj}|r&|dkr|n|d} | jd} | |krdS|d} t| tjr| dkrdS| dkr| n| d} | d } | dddfdk }| jd}n|}d |D} t|}tt|t|D]}| ||kr||||||}tt|| |}|dkrW|rG||r| n| |}tj|| d| j| j | |||z |f<|| d||| d<dS) a;Restore the trailing chat-template suffix that truncation may have removed (in place). Chat templates append fixed tokens after the content (e.g. an assistant prefill or EOS) that right-truncation cuts off first. That is harmless for mean/CLS pooling but breaks models that read the final position (causal-LM rerankers, last-token pooling), so the suffix is written back over the final real tokens of every truncated row. This must happen post-hoc: the tokenizer truncates the rendered string blind to template structure, with no upstream option to trim only the content. Only rows whose real length reached ``max_length`` can have been truncated, so shorter rows are skipped. The suffix is derived (and cached) per row, handling batches that mix role layouts. rNrrrJrrrc,g|]}t|SrD)len)rrows rFrz=Transformer._restore_chat_template_suffix..s555CHH555rE)rr)rrr(rrr unsqueezernumelrsumtolistrranger_chat_template_suffix_ids as_tensorrr)rsr*rrrrrYr is_tensoridswidthram real_lengths left_paddedn_rowsrowsindexsuffixkeepends rFrxz)Transformer._restore_chat_template_suffixs(LL-- )elD%9::  F _1 y%,77  (}}!33))9L9LQ9O9OCIbMEz!!&\\*:;;Nnel;; ~?S?S?U?UYZ?Z?Z#1#5#5#7#71#<#<.BZBZ[\B]B]B7799==Q=//6688Laaad8q=0022KYq\FFD55555LYYF3vs8}}5566 5 5EE"Z//33!57GFs6{{L$788Dqyy 5*51Jee|E7J/4vteff~UXU^gjgq/r/r/rE3:++,,&,dUVVnU TEFF## 5 5rE conversationlist[MessageInput] list[int]c  |r|j|gsgSn6#t$r)}td|gcYd}~Sd}~wwxYwd|||pifD\}}}|j}t t|t t|t t|t | |df}||vr||Sg} | |d|||} | |d|||} d} tt| t| D]\} } | | krn| dz } d| cxkr.tt| t| krnn| t| | z d}n4#t$r'}td|Yd}~nd}~wwxYw|||<t|tkrH |t#t%|n#t&t(f$rYnwxYw|S) arDerive one conversation's trailing chat-template suffix (cached). The conversation is rendered twice with different fillers: the longest common token suffix of the renders is the template tail, so no per-model token count is hard-coded. ``system`` messages are kept verbatim so a prompt the template renders in the tail is captured too. z+Could not derive the chat-template suffix: Nc3RK|]"}d|DV#dS)c,i|]\}}|tv||SrDrrs rFrzCTransformer._chat_template_suffix_ids...;s) m m mJCCGl.:sUA A  n m&,,.. m m mA A A A A A rEr0z1 2 3 4rr)rmr ExceptionrVror[reprrr_message_skeleton_render_message_skeletonrreversedrr _CHAT_TEMPLATE_SUFFIX_CACHE_SIZErr!iterr}rm)rsrrrrexccache cache_keyrfirstsecondcountrMrights rFrz%Transformer._chat_template_suffix_ids$s   t';'Q'QS_R`'a'a       LLLsLL M M MIIIIII A A /1A=CVTVWA A A =. 0 ,224455 6 6 (..0011 2 2  ++--.. / / '' b99 : :    # # N11c#79I=E22i)=?OQ^FE"8E??HV4D4DEE   e5==E 577773s5zz3v;;7777777s5zzE1334 N N N LLLsLL M M M M M M M M N "i u::8 8 8  $tE{{++,,,,l+     sE" AA AA.CG22 H#<HH#/I44JJfillerc2g}|D]}t|tr|ddkr||Ft|dtrd|dgn|}|i|d|i|S)aReplace each non-system message content with ``filler``, keeping everything else verbatim. Keeping system messages whole lets the derivation capture a prompt rendered in the tail. Fillering the rest keeps the renders tiny regardless of input length. rolesystemrr)r{r)rrrrr)rsrrskeletonrO new_contents rFrzTransformer._message_skeletonis # A AGgt,,  F0C0Cx0O0O(((@J7;;W`KaKacg@h@htFF;;<.s#OOOe#urErNrJ).rJall_special_idsr) rrrYr rrNrrhr)rsrrrtokenized_promptr rN last_tokens rFrzTransformer._get_prompt_lengths POv||~~OOO5fV\\^^4455 3 3 3.y9 9*4?F8>>v>> . . .59D ' 24(5;B? N %k27;@@BB  WY8I%J%J z]f]vOvOv Q M1>#I.rE*tuple[PeftConfig | PretrainedConfig, bool]c t||d|d|d|dd|dd}|H|d krtd tst d d dlm}|j|fi|dfStj|fi|dfS)aeLoads the transformers or PEFT configuration Args: model_name_or_path (str): The model name on Hugging Face (e.g. 'sentence-transformers/all-MiniLM-L6-v2') or the path to a local model directory. backend (str): The backend used for model inference. Can be `torch`, `onnx`, or `openvino`. config_kwargs (dict[str, Any]): Keyword arguments passed to the Hugging Face Transformers config. Returns: tuple[PeftConfig | PretrainedConfig, bool]: The model configuration and a boolean indicating whether the model is a PEFT model. cache_dirrrevision subfolderrlocal_files_onlyF)rrrrrNr(aPEFT models can currently only be loaded with the `torch` backend. To use other backends, load the model with `backend="torch"`, call `model.transformers_model.merge_and_unload()`, save that model with `model.save_pretrained()` and then load the model with the desired backend.zgLoading a PEFT model requires installing the `peft` package. You can install it via `pip install peft`.rrTT) r.rrr-r|r`rUrr)rsr0r,r+adapter_config_filerUs rFr\zTransformer._load_configs7 #'' 44##G,,"&&z22#'' R88*../A5II      *'!! w %&& !} ( ' ' ' ' '-:-.@RRMRRTXX X)*<NN NNPUUUrErpPeftConfig | PretrainedConfigcbt|tsdS|gt|drW|jD]=}t ||d}t|tr|>dfd }|d d td|ddtddS)zqWarn if the config requests bidirectional attention settings not supported by the installed transformers version.NrUparamreexpected_valuer is_supported min_versionrrr8c |stfdDsdStdddtd|d dS)Nc3>K|]}t|duVdSrr)rcfgrrs rFrzaTransformer._warn_on_unsupported_attention_config..warn_if_unsupported..s5&o&oWZwsE4'@'@N'R&o&o&o&o&o&orEzThe model config specifies `=z-`, but the installed `transformers` version (z) may not support this parameter, in which case it may be silently ignored and the model will fall back to its default attention behavior (often causal), likely producing degraded model outputs. Consider upgrading with `pip install -U "transformers>=z"`.)rrVrWtransformers_version)rrrrconfigs_to_checks`` rFwarn_if_unsupportedzNTransformer._warn_on_unsupported_attention_config..warn_if_unsupporteds 3&o&o&o&o&o^n&o&o&o#o#o  NNCuCC~CC+?CC3> CCC     rEuse_bidirectional_attentionTrV is_causalFrW) rrerrrrrrerrr8) rr rhrUrUr~r2_TRANSFORMERS_SUPPORTS_USE_BIDIRECTIONAL_ATTENTION&_TRANSFORMERS_SUPPORTS_IS_CAUSAL_FALSE)rprWrXrrs @rFr]z1Transformer._warn_on_unsupported_attention_configs&"233  F4:8 6= ) ) 8#)#5#:#:#<#< 8 8$V_dCC j*:;;8$++J777        )41cem    K0VX_`````rEruc T|dkrd|r|dd|dkr|j||fi|}||S|dkrt|}n t|}|j|fd|i|S|dkrt d |||d|S|d krt d |||d|Std |d ) aqLoads the transformers or PEFT model into the `auto_model` attribute Args: model_name_or_path (str): The model name on Hugging Face (e.g. 'sentence-transformers/all-MiniLM-L6-v2') or the path to a local model directory. config ("PeftConfig" | PretrainedConfig): The model configuration. backend (str): The backend used for model inference. Can be `torch`, `onnx`, or `openvino`. is_peft_model (bool): Whether the model is a PEFT model. model_kwargs (dict[str, Any]): Keyword arguments passed to the Hugging Face Transformers model. r(rNr]rbrponnx)r0rp task_nameopenvinozUnsupported backend 'z6'. `backend` should be `torch`, `onnx`, or `openvino`.rD)r_load_encoder_only_modelrrrr0r1r) rsr0rrpr,rur)r_ model_clss rFr^zTransformer._load_models=& g   3  T222#777556H&aaT`aa$ L;..:6BB :;KL ,9,-?___R^__ _   "#5*    " "&#5*  tWtttuu urEPreTrainedModel | Nonec ld fd }ttrddlm}d_||Stt rddlm}||jdStD]E\}}} t|r/ttj || } || cSFdS) a\Load encoder-only variants for encoder-decoder architectures. Checks :data:`_ENCODER_ONLY_MODELS` for standard mappings and handles a few special cases (T5Gemma, T5Gemma2) that require extra configuration before loading. Returns the loaded model, or None if the config doesn't match any encoder-only architecture. Nc|t|fddgi|5|jfd|picdddS#1swxYwYdS)N"_keys_to_ignore_on_load_unexpectedz decoder.*rp)rr)r load_configextra_class_attrsrpr)r0s rF _load_encoderz;Transformer._load_encoder_only_model.._load_encoder= s*?JmO` s s1y01CrrKLa[areqrr s s s s s s s s s s s s s s s s s ss 155r)T5GemmaEncoderModelF)rz model.encoder)rbase_model_prefixr) rrLrris_encoder_decoderrH.transformers.models.t5gemma2.modeling_t5gemma2rencoderrr~ importlib import_module) rsr0rpr)rrr config_cls module_path class_name encoder_clss ``` rFrz$Transformer._load_encoder_only_model/ s s s s s s s s s fm , , 6 8 8 8 8 8 8(-F % =!455 5 fn - - q V V V V V V!=fn`oppp p4H 2 2 /J Z&*-- 2%i&=k&J&JJWW $}[11111 2trEr_rRmProcessorMixin | PreTrainedTokenizerBase | FeatureExtractionMixin | BaseVideoProcessor | ImageProcessingMixintuple[ModalityConfig, str]cFt|j\}}|dd|||x}P|\}}t|dr7|j0d|vr,i|dddd|jji|d<||fS||}t|dr|j| d| |j } | | vr6i}|D]-} td} | dkr|jj| d<| || <.||fS|jd krdi}|D][} | dkr d | d } t|| r. s4    B\]]   rE)rrinfer_modalities_edge_casesrhrrrmrQinfer_modalities_from_processorr_get_method_output_fieldsrrkr~)rsr_rRdefault_modality_configdefault_module_output_nameresultrrr output_fieldsr entryrArfmethod_output_fieldsrs @rFrnzTransformer.infer_modalitiesX s?XX\Xm>n;!;%-$O$O.0O& 2 2&iLfgggy((&*&:&IE(O,1))"$>> >  $8 8 8.0O& h hy((8X888 5+..h$UK88F+/+I+I&+Q+Q(+hCW0W0W?Jbq4r4r11?Jbf4g4g1"$88 8    &    && &rEXProcessorMixin | PreTrainedTokenizerBase | FeatureExtractionMixin | ImageProcessingMixin!tuple[ModalityConfig, str] | Nonect|j}|dS||jj}|dS|\}}}|s||fSi}|D]\} } t || ds(td| dd| dCt|| d} | d| | d| d|| <||fS)a Return a ``(modality_config, module_output_name)`` for model types that cannot be handled by the general :meth:`infer_modalities` inference path, or ``None`` to fall through. Looks up the model type in the task-specific edge case configs from :data:`_EDGE_CASE_MODALITY_CONFIGS`. For entries that require output name validation (transformers v4/v5 compat), resolves each modality's ``method_output_name`` against the actual model method via :meth:`_infer_method_output_name`. NrfzModel does not have method z for modality z . Skipping.rhr) rrrrpryrrhrVrr~_infer_method_output_name) rsr_rRtask_edge_casesr raw_configrvalidate_output_namesrr rzrfs rFrz'Transformer.infer_modalities_edge_cases s6699$:OPP  "4##EL$;<< =4@E= &(=$ 211 1*, * 0 0 2 2   Hf5&"233 ##k&2BkkT\kkkUF8$455F *&*&D&DVL`Eaci&j&j))OH % % 222rEcddddd}t|tr6|pifd|DStt t td}|D]\}}t||r|gcSt dt|j d gS) zWDetermine which modalities the processor supports by inspecting its attributes or type.rrrr)rNimage_processorfeature_extractorvideo_processorc"g|] \}}|v | SrDrD)rprocessor_attributer?processor_attributess rFrz?Transformer.infer_modalities_from_processor.. s46'&*>>>>>>rE)rrrrz6Could not determine modalities from processor of type z#. Returning an empty modality list.) rr#_get_processor_attributesrr"rr>rrVrWr{rA)rsrRprocessor_attribute_mappingmodality_checksr?rprs @rFrz+Transformer.infer_modalities_from_processor s  &!(& < < # i 0 0 #'#A#A#C#C#Ir :U:[:[:]:] ,+') 1 1  />.C.C.E.E ' ' *M?)_55 '%&&& '  0T)__E] 0 0 0    rElist[str] | Nonect|jdr|jSt|jdr |jjSdS)zGet the attributes of the processor if available. Will be removed in the future as transformers v5 becomes the minimum requirement. Returns: list[str] | None: The processor attribute names, or None if not available. get_attributes attributesN)rhrRrrr}s rFrz%Transformer._get_processor_attributes sQ 4>#3 4 4 ->0022 2 T^\ 2 2 ->, ,trErfrcfd t|dd}n#t$rYdSwxYw|}|dSdt|DS)zExtract the output field names from a method's return type annotation. Args: method (Callable): The method to inspect. Returns: list[str] | None: List of output field names, or None if not found. ct|trt|tr|St |D]}|x}|cSdSr)rr{ issubclassr+r )type_annotationsub_annotationrfind_model_output_classs rFrzFTransformer._get_method_output_fields..find_model_output_class sn/400 'ZQ\5]5] '&&"*?";"; " "55nEEEFR!MMMS4rErrNcg|] }|j SrD)r)rfields rFrz9Transformer._get_method_output_fields.. s===u ===rE)r rrr)rfreturn_annotation output_classrs @rFrz%Transformer._get_method_output_fields s       .v 6 6 : :8T J J     44 ../@AA  4==|(<(<====s #, ::rhcJt|pg}||vr|SdS)aValidate that ``method_output_name`` is present in the method's return type annotation. Returns the name if found, or ``None`` if the method's output type does not include it. Primarily needed for transformers v4 compatibility: v5 often allows ``pooler_output`` from ``get_..._features`` methods, but v4 didn't use ``BaseModelOutputWithPooling`` yet. N)rr)rhrfrs rFrz%Transformer._infer_method_output_name s2$==fEEK  . .% %trEsafe_serialization output_pathr&c|j|||j|||dS)z@Save the model, processor, and module config to ``output_path``.r%N)r_save_pretrainedrR save_config)rsr'r&argsrs rFsavezTransformer.save sN "";CU"VVV &&{333 %%%%%rErrrbool | str | None cache_folderrrtrust_remote_code init_defaultsr=c |||||||||| | |  }| piD]\}}||||dd|i|S)zWLoad a Transformer module from a pretrained model directory or Hugging Face model name.) r0rrr.rrr/r)r*r+r,r0rD)_load_init_kwargsr setdefault)rr0rrr.rrr/r)r*r+r,r0r init_kwargsrrs rFloadzTransformer.load# s(++1%-/%-',   ).B5577 / /JC  " "3 . . . .sHH&8HKHHHrEc  N|||||||} ||||||d}dddd}|D]7\}}|| vr| || |<| |i8| d|| d|| d||r| d|| r| d| | r| d| i| d| iS)zBuild the kwargs dict for ``__init__`` by merging config file, hub kwargs, and caller overrides. Priority (highest to lowest): caller kwargs > hub kwargs > config file values. )r0rrr.rr)rrrrrr/r)r*r+) model_argstokenizer_args config_argsr,)rrrr3r)rr0rrr.rrr/r)r*r+r,rrp hub_kwargs _OLD_TO_NEWold_namenew_names rFr2zTransformer._load_init_kwargsI s,1%- !  #% 0!2   )0*  #."3"3"5"5 , , Hh6!!#)::h#7#7x   h + + + + ~%%j111!"))*555&&z222  8 > " ) ), 7 7 7  @ % & - -.> ? ? ?  : ? # * *= 9 9 9-&-)W---rEconfig_filenamec |r|gngd}|D].}t|||||||} | rn/dD]+} | | vr%d| | vr| | d,d| vrhdi} | dD]\} } d| vrZt | d}fd|D}|r"t d |d | d ]| | |<c| vrt d | d | | | <| | d<n|| \| d<| d<| S)aLoad the module config, trying several legacy config filenames for backward compatibility. Handles deserialization of ``modality_config`` tuple keys (stored as comma-separated strings in JSON) and strips ``trust_remote_code`` from all sub-dicts for security. )rzsentence_roberta_config.jsonzsentence_distilbert_config.jsonzsentence_camembert_config.jsonzsentence_albert_config.jsonz sentence_xlm-roberta_config.jsonzsentence_xlnet_config.json)r0rr>rr.rr)r7r)r8r*r9r+r/r>rrrrrO+cg|]}|v| SrDrD)rrGvalid_single_modalitiess rFrz+Transformer.load_config.. s$TTTQ1rr.rrconfig_filenamesrprdeserialized_modality_configryrzpartsinvalidrBrqs @rFrzTransformer.load_config s$ _    0  OWW((#5# /)!!1)F   5 5Cf}}!4s !C!Cs  3444  & &&T&T&T #+- ((./@(A(G(G(I(I H H$ f,&&!,"4"4S"9"9::ETTTT%TTTG!xGxxgsxxx!:@077#+BBB'l 'l'l'lmmm AG0>>(DF$ % %GJFfFfgmFnFn CF$ %v.B'C rEcDt|ddS)aGet the default modality configuration for the current transformer task. Returns: tuple[ModalityConfig, str]: A tuple of (modality_config, module_output_name). The modality_config maps modality keys to dicts with 'method' and 'method_output_name'. The module_output_name is the name of the output feature this module creates. rr])rr)rps rFrDz(Transformer._get_default_modality_config s)4FH\)])]^^rEct}d|jD|d<|js|dd|j|dd|jD]4\}}|||kr||d5|S)zdReturn the config dict for serialization, with tuple modality keys joined as plus-separated strings.c4i|]\}}t||SrD)r3)rr rzs rFrz/Transformer.get_config_dict.. s3* * * 2B(FOH % %v* * * rErr Nr!) rSget_config_dictrrr rr!r%r)rs config_dictrdefaultrqs rFrLzTransformer.get_config_dict sgg--// * * FJFZF`F`FbFb* * * %&% 7 OO/ 6 6 6   $ OOND 1 1 1!7==?? + +LCs##w..T***rEcndt||jjjdS)Nz Transformer()r))rrLr_rqrAr}s rF__repr__zTransformer.__repr__ s4id4#7#7#9#9 H\HefffiiiirE)"r0rerr1r)r2r*r2r+r2r r3r,r4rr5rrgr!r6r"r7r#r7rrr-r7r.rr/rgrrr8)rrr6)rr6rrr8)rrr)rrrrr8)rrrrr8rrr)rrr)rrr7)rr7rrr8)rrr!)rrr )rrr)rrr)r r7rrrr rrr)NN)rrrrgr r3rrr)r rrrrrr8)rrrrrrrrr8)r%r3rrr)r*rrrrr) r r7rrZrrrrrr2rrr) r r7rrZrrrrrrr) rrtrrrrrr2rrr) rrtrrrrrrrrr)r*rrrtrrrrrr2rYr7rrr8) rrrrrrrr2rrr)rrrrerrr) rrrrerrrrrrrrr)rrerrr7)r0rer,rer+rrrr)rprrrr8) r0rerr1rprr,rerurrrr!)r0rerpr rrr)r_r!rRrrrr)r_r!rRrrrr)rRrrrr)rrr)rfrrrr)rhrerfrrrrg)r'rer&rrrr8) rNNNFFNNNr(N)r0rerrerr-r.rgrrgrrr/rr)r2r*r2r+r2r,rer0r2rrr=) rNNNFFNNNr()r0rerrerr-r.rgrrgrrr/rr)r2r*r2r+r2r,rerrr)rNNNNF)r0rerrer>rgrr-r.rgrrgrrrrr)rprrrr)rrr)rrre)?rArBrCrnrrir$r%r&r'r;rTpropertyr!setterrrrrr-rrprrNrrrr rrrrrYrr]r^r\rwrxrrrrr\ staticmethodr]r^rrnrrrrrr, classmethodr5r2rrDrLrQ __classcell__)rqs@rFrrshhT87777   K    .. L.l.l.l!llll! -A.226/3598?15)-$(#'&*7;%)#-1%v/v/v/v/v/v/v/"!v/p " " "X "    %%%X%****0BGGGGR    X 4444 X!!!X!111X1:::X: o o o o    ( Z Z Z Z"59 } } } } } ~' ' ' ' R) ) ) ) V4ffffP7 7 7 7 ~7; ,p,p,p,p,p\, , , , \    L7; ,,,,,\X X X X @04!%B5B5B5B5B5R04 CCCCCJ    B6&V&V&V&VPaaa\a84v4v4v4vl''''RC&C&C&C&J%3%3%3%3N!!!!F    >>>\>6   \ HL&&&&&&  #'#'#!&"'.226/3/3#I#I#I#I[#IJ #'#'#!&"'.226/3B.B.B.B.[B.H&*#'#'#!&RRRRRR[Rh___\_"jjjjjjjjrEr)rprqrrrsrR)rrrrr)rrrrr) __future__rrrDcollections.abcrr contextlibr dataclassesrtypingrr r r r r r(packaging.versionr parse_versiontokenizers.normalizersrrrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*rtransformers.utilsr+r,transformers_loggingtransformers.utils.import_utilsr-transformers.utils.peft_utilsr.typing_extensionsr/sentence_transformers.backendr0r1#sentence_transformers.base.modalityr2r3r4)sentence_transformers.base.modality_typesr5r6r7r8r9/sentence_transformers.base.modules.input_moduler:%sentence_transformers.util.decoratorsr;&sentence_transformers.util.environmentr<r=r|r>rHrIrLrNrPrRr`rU get_loggerrArVrjrrr frozensetrrr1rdrkrModalityConfigrrrirrrrrr_TEXT_GENERATION_EDGE_CASES_ANY_TO_ANY_EDGE_CASESrrrrrrrrr r-rgrrDrErFrpsE"""""""........%%%%%%SSSSSSSSSSSSSSSS 444444,,,,,,AAAAAA8=<<<<<******>>>>>>======BBBBBB))))))NNNNNNNNqqqqqqqqqqHGGGGGNNNNNNMMMMMM''''&&&&&&&&' ///////               ?????????                       *******               ,,,,,,,               .......               ///////               &&((  (  ( 2 23@=AU3V3VYfYfgoYpYp3p0@M Nb@c@cgtgthhA=6C]CW5X5X\i\ijr\s\s5s2)67K)L)LP]P]^ePfPf)f&)2 2k2k2k(l(l%#& n #####i### *****,E****h./####N$A+% >> 555555 !#<00   D  I=PQQR IXFFG  IXFFG IXFFG IXFFG ) MM )NN    -PPD~/0 12!34!34>#78~':;~/OPKM`aH  A?SBDTUGIZ[HJ\]BDTU?QIK\]-5>&=PQQ&/GZ[[ <hO 2/ZZ 4O\\*C[jkk    hO 2J]^^ 4L_``    hO& 2J]^^ 5M`aa     'hO6 2/ZZ 4O\\    7hOH (@STT*3K^__     IhOX(@STT*3K^__    YhOj yH[\\] khOt yH[\\] uhO~ yH[\\] hOH yH[\\]  IhOT )ATUU*3K^__    UhOf(@STT )ATUU*3K^__   ghOz ${hO|'}hO~ !hO@ #AhOB+ChOD(&0 #%.OhOhOhOhhhhZ  JJ    F     )II*38TT      yII   0 )II*38TT      yQQR   yQQR  yQQR  yQQR !*JJ*38TT    A((V92(& WW&&& " " " " "y " " " " )))))9)))X)R(Q(QQQQQ5E!EEEED""""<$)   %9%v%v%vww|!j|!j|!j|!j|!j+|!j|!j|!j|!j|!jsC C.-C.2C99D DDD=<D=EEE!E((E=<E=FFF!F((F=<F= JJ'&J'