>:jh\%SSKJr SSKrSSKrSSKJr SSKJr SSKJ r SSK J r J r J r JrJrJr SSKrSSKJr SSKJrJr SS KJrJrJrJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2 SS KJ3r4 SS K5J6r6 SS K5J7r8 SS K9J:r: SSK;Jr>J?r? SSK@JArAJBrB SSKCJDrDJErEJFrFJGrGJHrH SSKIJJrJ SSKKJLrL SSKMJNrN SSK JOrO SSKJRrR SSKJSrSJTrT SSKJUrU SS!KJVrV SS$KJWrW \ (a\:"5(aSS'KXJYrY \8R"\[5r\\"\45\"S(5:r]\"\45\"S)5:r^\ S*r_"S+S,\5r`"S-S.\`S/S09ra\b\F\a4rc\\\\S1.rdS2\eS3'SS4KJfrf \f\dS5'S6S7S8S9.0S:4S6S7S;S9.0S<4S6S7S;S9.0S=4S6S7S;S9.0S=4S6S7S;S9.0S:4S*.rgS>\eS?'\/S@SA4\&S@SB4\1S@SC4\0S@SD4\#S@SE4\-S@SF4\.S@SG4\SHSI4\ SJSK4\$SLSM4\'SNSO4\(SPSQ4\VSRSS4\2STSU4\%SVSW4\TSXSY4/rhSZ\eS['S7S8S9.S7S8S9.S\.S:S/4riS]\eS^'0S_S`SaS9.SbSaS9.ScSaS9.Sd.SeSf4_SgS`S8S9.SbS8S9.Sh.S:Sf4_SiS`S8S9.SjS8S9.Sh.S:Sf4_SkS`SaS9.SbSaS9.Sh.S:Sf4_SlS7S8S9.S7S8S9.Sm.S:S/4_SnS7S8S9.S7S8S9.Sm.S:S/4_SoSpS7S8S9.0S:S/4_SqSpS7S8S9.0S:S/4_SrSpS7S8S9.0S:S/4_SsSpS7S8S9.0S:S/4_StS7S8S9.S7S8S9.Su.S:S/4_SvS7S8S9.S7S8S9.S7S8S9.Sd.S:S/4_Sw\i_Sx\i_Sy\i_Sz\i_S{\i_\i\i\i\i\i\iS|.ErjS}\eS~'SSS7S;S9.0S:S/40rkS}\eS'S7S;S9.S7S;S9.Sm.S=S/4S6S7S;S9.0S=S/4S.rlS7S;S9.S7S;S9.Sm.S=S/4SpS7S;S9.0S=S/4SpS7S;S9.0S=S/4SpS7S;S9.0S=S/4SpS7S;S9.0S=S/4S7S;S9.S7S;S9.S\.S=S/4S.rm\j\l\m\kS.rnS\eS'SSjro\S5rp"SS\S/S09rqSSjrr"SS\J5rsg!\Pa SSKQJOrO GNf=f!\Pa "SS5rRGNf=f!\Pa "SS5rS"SS5rTGNf=f!\Pa "SS 5rUGNf=f!\Pa "S"S#5rVGNf=f!\Pa "S%S&5rWGNf=f!\Pa GNf=f)) annotationsN)Callable)contextmanager)fields) TYPE_CHECKINGAnyLiteral TypedDictget_argsget_type_hints)parse) LowercaseSequence) AutoConfig AutoModelAutoModelForCausalLMAutoModelForMaskedLM"AutoModelForSequenceClassification AutoProcessorBlenderbotConfigBlenderbotSmallConfigFeatureExtractionMixinImageProcessingMixin LongT5Config M2M100Config MarianConfig MT5Config PegasusConfigPegasusXConfigPretrainedConfigPreTrainedModelPreTrainedTokenizerBaseProcessorMixinProphetNetConfigSwitchTransformersConfigT5Config UdopConfig UMT5Config WhisperConfig) __version__) ModelOutput)logging)is_peft_available)find_adapter_config_file)load_onnx_modelload_openvino_model)InputFormatterformat_modality)MODALITY_TO_PROCESSOR_ARG MessageInputModality PairInput SingleInput) InputModule)transformer_kwargs_decorator)suggest_extra_on_exception)Self)BaseVideoProcessorc\rSrSrSrg)r<EN__name__ __module__ __qualname____firstlineno____static_attributes__r?k/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sentence_transformers/base/modules/transformer.pyr<r<E rFr<)T5Gemma2ConfigT5Gemma2TextConfigc\rSrSrSrg)rIMr?Nr@r?rFrGrIrIMrHrFrIc\rSrSrSrg)rJPr?Nr@r?rFrGrJrJPrHrFrJ) T5GemmaConfigc\rSrSrSrg)rOXr?Nr@r?rFrGrOrOXrHrFrO)MoonshineConfigc\rSrSrSrg)rR`r?Nr@r?rFrGrRrR`rHrFrR)TimmWrapperConfigc\rSrSrSrg)rUhr?Nr@r?rFrGrUrUhrHrFrU PeftConfigz4.56.1z 5.4.0.dev0)feature-extractionsequence-classificationtext-generation any-to-any fill-maskc*\rSrSr%S\S'S\S'Srg)_ModalityParamsRequired{strmethod str | Nonemethod_output_namer?N)rArBrCrD__annotations__rEr?rFrGr`r`{s K""rFr`c$\rSrSr%SrS\S'Srg)ModalityParamszParameters 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']formatr?NrArBrCrD__doc__rfrEr?rFrGrhrhs *)rFrhF)total)rZr[r\r^zdict[TransformerTask, Any]TRANSFORMER_TASK_TO_AUTO_MODEL)AutoModelForMultimodalLMr]textforwardlast_hidden_statercretoken_embeddingslogitsscores causal_logitsz1dict[TransformerTask, tuple[ModalityConfig, str]]TRANSFORMER_TASK_DEFAULTS transformersT5EncoderModelMT5EncoderModelUMT5EncoderModelUdopEncoderModelLongT5EncoderModelProphetNetEncoderSwitchTransformersEncoderModelz2transformers.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)audiorrpz tuple[ModalityConfig, str, bool]_AUDIO_MODALITY_CONFIGblipget_text_features pooler_outputget_image_featuresget_multimodal_features)rpimagerrpsentence_embeddingTblip-2)rprsam3get_vision_featuresflavagit)rpr 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)rZr\r]r^z6dict[str, dict[str, tuple[ModalityConfig, str, bool]]]_EDGE_CASE_MODALITY_CONFIGScUcg[U[5(ag[U[5(a[SU55$g)zVCheck whether a tokenizers normalizer (or sequence of normalizers) includes Lowercase.FTc3B# UHn[U[5v M g7fN) isinstancer).0ns rG !_has_lowercase..s@Z:a++Z)rrrany) normalizers rG_has_lowercasers<*i((*h''@Z@@@ rFc +@# UVs0sHo"[XS5_M nnUR5Hup$[XU5 M Sv UR5Hup$[XU5 M gs snf!UR5Hup$[XU5 M f=f7fr)getattritemssetattr)cls overridesname originalsvalues rGset_temporary_class_attrsrsSj5rS?S@SjjrSASjrSBSjrSCSjrSCSjrSCS jrSDS!jrSES"jrSFS#jrSGS$jrSHS%jrSIS&jrSJS'jr SKS(jr!SLS)jr"\#SMS*j5r$\#SNS+j5r%S S,.SOS-jjr&\'SPSQS.jj5r(\'SPSRS/jj5r)\'SSSTU4S0jjj5r*\#SUS1j5r+SVU4S2jjr,SWS3jr-S4r.U=r/$)X Transformeria]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``: Device map for model parallelism, e.g. ``"auto"``. - ``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. 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, ``"feature-extraction"`` 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. 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.jsonrbconfig_file_name)transformer_taskmodality_configmodule_output_nameprocessing_kwargs unpad_inputsz list[str] config_keysTbool save_in_rootrZNtorchF) r model_kwargsprocessor_kwargs config_kwargsrbackendrrrmax_seq_length do_lower_casetokenizer_name_or_pathc  >[TU]5 U[;a=US:Xa [S5e[ SUS[ [R 5535eX lUc0nUc0nUc0nU=(d 0Ul1Skn[UR5U- nU(a%[RSUS[U5S35 Xpl XlS Ul0Ul0UlUR%XU5unnUS :Xa;S U;a5UR&b![)S UR&55(dS UlUR,"XUUU40UD6Ul[[0R2"UR.R45R651Sk-UlU b SU;aXS'[;5 [<R>"U bU OU40UD6Ul SSS5 URBGbISU;ax[EURFS5(a]URFRHS:waC[KURBRLURFRH5URBl&U (aURBRN(aURBRPRRn[UU5(dg[W5/n[YU[Z5(aU[ U5- nOUbUR]U5 [[U5URBRPl)OXRBlURS;aGSUR@l1[EUR@S5(aSUR@RBl1UbSU;aUSReSS5nOSn[gURFRhUUR@S9Ul5UbiXl6U c [ S5eXl7URq5H:unn[YU[r5(aSU;dSU;dM)[ SU<SU<35e O3URuUR.UR@5uUl6Ul7[RwSURl35 [ URlR 55URjl<U bN[RS5 UR@RzR|UR.RFl?Xl@g!,(df  GNW=f![^a XRBR`lGN*f=f) 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: >rprrrrrz%Unknown keys in `processing_kwargs`: z. 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_labelsc3B# UHoRS5v M g7f)ForSequenceClassificationN)endswith)rarchs rGr'Transformer.__init__..{sgRf$==)DEERfrr> input_ids return_dict inputs_embedsattention_masktoken_type_idsmodel_max_lengthmax_position_embeddingsr\r]left tokenizermessagerjauto) model_typemessage_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".rcrez"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.)Asuper__init__rn ImportError ValueErrorrkeysrrsetloggerwarningsortedrrtrack_media_counts_prompt_length_mapping_method_signature_cache _load_config architecturesrr _load_modelmodelinspect signaturerq parametersmodel_forward_paramsr:rfrom_pretrainedrrhasattrconfigrminris_fastbackend_tokenizerrrrrrrAttributeErrorbasic_tokenizer padding_siderr1rinput_formatterrrrrinfer_modalitiesdebugsupported_modalities __class__rAtokenizer_classr)selfmodel_name_or_pathrrrrrrrrrrrr valid_keys unknown_keysr is_peft_modelrnew_normalizersr modality_keyparamsr's rGrTransformer.__init__As$  #A A</!Z01A0BBZ[_`~aDaDaF\G[HI 2B  L  #!   M3D3JS 4112Z?  NN7 ~F##)*#5"67RR   *"'&(#<>$ $ 1 12D} ]   9 9M1$$,gRXRfRfggg !"F %% &'= T`  %((9(9$**:L:L(M(X(X$Y] % !  %*> %#*::DKK)BCCKK772=25NN33T[[5X5X3/>>))!%!A!A!L!LJ)*55+4;-%j(;;+tJ/??O'3+22:>FNF_88CU7D4  $E E*0DNN 't~~{338>((5  &9+G,Y7;;HfMN#N-{{--nX\XfXf    !) N '9 #(7(=(=(?$ f!&$//863IMaioMo$<\&+D #&*&>&>&@D #}T%<%<5&=}rFcPURS:wdqSUR;daURS:wdQ[URSS5"5(a/[ SURR 555(agSS KJn SS K J n SS K J n UR R"nU"US 9(dgU"U5utpV nUcg[RS5 U"SSSS9UlU=R&1Sk-slg![a [RS 5 gf=f)axDetermine 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"`` task, as model heads (e.g. ``AutoModelForSequenceClassification``) are incompatible with flattened inputs. 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. rZrpris_backend_compatiblecg)NFr?r?rFrG1Transformer._can_flatten_inputs..srFc30# UH oSS:gv M g7f)rcrqNr?)rr0s rGr2Transformer._can_flatten_inputs..s]?\V(#y0?\sFr)DataCollatorWithFlattening)lazy_import_flash_attention)is_flash_attention_requestedz~Consider upgrading to transformers >= 5.0.0 to skip padding for text-only inputs, which can significantly speed up processing.)"requested_attention_implementationzuUsing 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)rrrrrrvaluesryrA+transformers.modeling_flash_attention_utilsrBtransformers.utils.genericrCrr r%r_attn_implementation data_collatorr)r)rArBrCattn_implementation_flash_varlen_fns rGr8Transformer._can_flatten_inputss 0  ! !%9 9T111||w&4::'> NPP]t?S?S?Z?Z?\]]]  ? _ O#kk>>+Obc&ABU&V# a!  "  D 8%) $  !!&  !C  LL?   sDD%$D%cDURbURR$[URRS5(a%URRR 5nOURRn[US5(a UR $g)zThe maximum input sequence length. Reads from the tokenizer if available, otherwise falls back to ``max_position_embeddings`` from the model config.Nget_text_configr)rrrrrrWr)r) text_configs rGrTransformer.max_seq_lengthFs| >> %>>22 2 4::$$&7 8 8**++;;=K**++K ; 9 : :66 6rFc@URbXRlgg)zTSet the maximum input sequence length. Only effective when a tokenizer is available.N)rrr9s rGrrYWs >> %.3NN + &rFcUR$)z!The underlying transformer model.)rr4s rG auto_modelTransformer.auto_model]szzrFc.URR$)z#The underlying model configuration.)rrr4s rGrTransformer.configbszz   rFcH[URR55$)z]The list of supported input modalities (e.g. ``"text"``, ``"image"``, ``("image", "text")``).)rrr r4s rG modalitiesTransformer.modalitiesgsD((--/00rFc[UR[5(a UR$[URSS5$)zVThe tokenizer, extracted from the processor. Returns ``None`` for non-text processors.rN)rrr"rr4s rGrTransformer.tokenizerls3 dnn&= > >>> !t~~{D99rFc U(d0$SS0nSSS.SS000S.nURRS:XaS US S'S UR;aURURS 5 UH:nURR U5=n(dM'XVRU5 M< UR R U5upn U R5HupkXVRU 5 M UR=(a6 US :H=(d* US :H=(a UR RU S 5n U (a US US RSS5 SUS S'S UR;a$US :waUR RX5upOcXR;aT[S[U5SSRS[!URR#5[$S95535eSn U(a)US :Xa#UR R'U S U5U S 'OBU(a;US :Xa5UR R)U S U5U S 'UR*"U40UD6n SnSnUR,(a'UR.(aUS :Xa[1U S 5up[35 UR5XXT5nSSS5 Ub,SW;a&[6R8"U[6R:S9US'Ub,SW;a&[6R8"U[6R:S9US'U (a\[=WR?56Vs/sHn[A[=UU55PM nnURCU5nURSS5 UWS'U bU US'URDS;aCURFRHS:wa$[S URFRH<S!35eS"US#'U$!,(df  GN2=fs snf)$aaPreprocess 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. **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. return_tensorsptT longest_first)padding truncationri)rprrrr max_lengthrrrprNFreturn_attention_maskz Modality 'z8' is not supported by this model. Supported modalities: z, c38# UHn[U5v M g7fr)r2)rms rGr)Transformer.preprocess..s2|O{!?13E3EO{s)keyimage_grid_thw)dtypenum_images_per_samplevideo_grid_thwnum_videos_per_samplelabelsmodality prompt_lengthrrzThe processor padding side is z, 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. Please set ``processing_kwargs={"padding_side": "left"}``.rlogits_to_keep)%rrrupdaterr# parse_inputsrr7is_text_only_messagespoprbatch_to_messager r2joinrr rbprepend_prompt_to_messagesprepend_prompt_to_texts_get_prompt_lengthtrainingrrr:_call_processorrtensorlongziprMrrQrrr")r)inputspromptkwargs common_kwargsmodality_kwargsr/rrwprocessor_inputsextra_modality_kwargs extra_kwargsshould_flattenrxrsruprocessor_outputrM per_samples rG preprocessTransformer.preprocessss!&I)40 $OD&   ;; ! !Y .3?OG $Y / t-- -  !7!7!A B+L 2266|DDyD-44Y?,=A+H 00   sI%q$*>*>*T*TUefoUp*q  ./ F # ' ' 4 8?DOF #$; < ,, ,Y1F)-)=)=)N)Nx)j &H& 11 1_X678))-2|vVZVjVjVoVoVqwzO{2|)|(}   h)+*.*>*>*Y*Y +V+ Y ' F*'+';';'S'STdekTlnt'u V $ 33FEfEM !% $ ==T44Y9N;RScdmSn;o 8 ! ' )#33HP_o * ! ,1AEU1U8= EZbgblbl8m 4 5 ,1AEU1U8= EZbgblbl8m 4 5 LOQaQhQhQjLklLk&$s#3V<=LkJl#11*=   4 0'/$  $0= _ -  $E E~~**f4 4T^^5P5P4STQQ 23 - .9* )ms5O3 P3 Pc URSS5nURUnUSnUSn[U[5(aU4nO [U[5(a [ U5n0UEUESS0En[ URUS5nUc[SUS 35eUS :Xa6UR5V V s0sHupXR;dMX_M n n n OURRU5n U c7[[R"U5R5n XRU'UR5V V s0sHupX;dM X_M n n n Ub S U;aSU S 'U"S0U D6n U nUbUHnXnM UR*S:Xa!UR-S5R/SS5nXUR0'SU;aSU;a[35(aSSKJn [URU5(aURR8R:(aoUSR<SnUSn[>R@"UURR8RBURDS9n[>RF"UU4SS9US'[IURRJS 5(a3URRJRL(aS U ;aU S US'U$s sn n fs sn n f![ ["4aE [ X5nGM![$a' [%S U<S['U5R(S35ef=ff=f)aiForward 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. rwrprcrerTNz#Model does not have the requested 'z' methodrq hidden_statesoutput_hidden_stateszCould not access output key z% via indexing or attribute access on .rrrr) PeftModel)device)dimall_layer_embeddingsr?)'rrrrbrtuplerrr rrrr rrrKeyError TypeErrorr rrAndimflatten transposerr-peftractive_peft_configis_prompt_learningshaperonesnum_virtual_tokensrcatrrr)r)featuresr modality_namemodality_params method_namere all_kwargs model_methodrprfiltered_kwargs method_params model_output embedding output_keyr batch_sizerprefix_attention_masks rGrqTransformer.forwardsJ&#+,,z6"B ..}=%h/ ,-AB (# . ."4!6  *D 1 1!&'9!: A@F@M4@ tzz;=  B;-xXY Y ) #>Q "))!,66q! > !!66<//;O/LH+ ,ut h!), $+I$B ),::.I""&y/":":!;1> s61K& K&< K, K,5K22M L1MMc^[TRR[5(a TRRR$U4SjnU"TRR5=nbU$[ TRRS5(a+U"TRRR 5=nbU$[ TRRS5(adTRRRR5H2n[TRRU5nU"U5=ncM0Us $ [S[TRR5RS35e)zGet 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. cn>[US5(aTRS:Xa UR$[US5(a UR$SHGn[X5(dM[ X5n[ U[ 5(aU(aUSs $MEUs $ [US5(a UR$g)Nprojection_dimr hidden_size)neck_hidden_sizes hidden_sizes embed_dimsr hidden_dim)rrrrrrrr)r attr_namerr)s rGget_hidden_size_from_configHTransformer.get_embedding_dimension..get_hidden_size_from_configSsv/00T5L5LPd5d,,,v}--)))P 6--#F6E!%.. #(9,! % Qv|,,(((rFrX sub_configszHCould not determine embedding dimension from model config. Config type: r) rrrrU num_featuresrrXrr rr rrA)r)rrsub_config_name sub_configs` rGget_embedding_dimension#Transformer.get_embedding_dimensionFs8 djj''): ; ;::$$11 1 *7tzz7H7HI IK V  4::$$m 4 4:4::;L;L;X;XYY f"" 4::$$m 4 4#'::#4#4#@#@#E#E#G$TZZ%6%6H #>z#JJKW&&$H VW[\`\f\f\m\mWnWwWwVxxy z  rFcUS:XaURUSX45$[UR[5(aUR XX45$UR XX45$)a8Call 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``). Returns: Processor output dictionary. r)_process_chat_messagesrrr#_call_multimodal_processor_call_single_modality_processor)r)rwrrrs rGrTransformer._call_processor{s]< y ../? /JOk k dnnn 5 5228n n33HP_oorFc pUR5VVs0sHupV[R"XU5U_M nnnURRS;d [ (d-US:Xa 0USEUSEnOX1nUR "S0UDUDUD6$UR "S0UDUSUSUSUSUS.D6$s snnf) zZCall a :class:`ProcessorMixin` processor, handling both legacy and v5 calling conventions.>rclipsegrrrprrr text_kwargs images_kwargs audio_kwargs videos_kwargsrr?)rr3rrr0_TRANSFORMERS_PROCESSOR_SUPPORTS_MODALITY_KWARGSr)r)rwrrrrprrs rGr&Transformer._call_multimodal_processors^n]s]s]uv]uzs599#CUJ]uv KK " "&D DCC,,POF3Pw7OP(2>>P$4PP-P P~~  '/)'2(1)'2'   !ws#B2cS[US4S[US4S[US4S[US4/nUHjupgn[ UR U5(dM#0UEUEn Xb;a(UR U5n UR "U 40UDU D6s $UR "S0UDU D6s $ [S[UR 5RS[U5S35e) zWCall a single-modality processor (tokenizer, feature extractor, image/video processor).rprrrz2Could not determine how to call processor of type z for modality ''r?) r"rr<rrrr} RuntimeErrorrrAr2) r)rwrrrprocessor_type_checks modality_typeprocessor_class type_kwargs call_kwargs primary_inputs rGr+Transformer._call_single_modality_processors ,of.E F ,og.F G (/'*B C *OG,D E ! >:[:M:K0 0 4 4] C ~~mW7GW;WW>>D$4D D Drirkrjrf)rrtokenizer_kwargsr) rr rr rrrrr#=_TRANSFORMERS_APPLY_CHAT_TEMPLATE_RECOMMENDS_PROCESSOR_KWARGSapply_chat_templater})r)rrrchat_template_kwargstop_level_kwarg_namesrptop_level_kwargss rGr"Transformer._process_chat_messagess D00 0))-d.B.B.G.G.I)J(KM  $5599/2N dnnn 5 5ML~~99! $#0#4#45E#F*9'*B*F*FG^`e*f'6v'>)8)A(7(@)8)A)6 & + ~~99 ! $ / 7"1'":!0!9"1'":"/ +  !ZCX[m[m[oCopCoC!2!23!77Cop=RekUlUqUqUs=s =sc(,,S1 1=s  ~~11  ,V4'    #  q s &F%F*c U/[UR55Q7nX0R;aURU$UR"U/40UD6nSU;aSURU'gUSRSnUR nUSSR 5nUb%[US5(aXvR;aUS-nXPRU'U$)zReturn the length of the prompt in tokens, excluding any trailing special token. Returns None if the processor does not produce ``input_ids``. rNr).rall_special_idsr) rrrrrrrrr)r)rr cache_keytokenized_promptrxr last_tokens rGrTransformer._get_prompt_length&s 5fV\\^45 33 3..y9 9??F8>v> . .59D ' ' 2(5;;B? NN %k27;@@B  WY8I%J%Jz]v]vOv Q M1>##I.rFc |[UURS5URS5URS5URSS5URSS5S9nUbFUS :wa [S 5e[5(d [ S 5eS S KJn UR"U40UD6S4$[R"U40UD6S4$)a%Loads 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_dirtokenrevision subfolderrlocal_files_onlyF)rrrrrraPEFT 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`.rrXT) r.rr r-rrrYrr)r)r*rradapter_config_filerYs rGrTransformer._load_config<s7 #'' 4##G,"&&z2#'' R8*../A5I    *'! w %&&!} (--.@RMRTXX X))*<N NPUUUrFc *US:XaUU(aURSS5 US:XaUR"X40UD6nUbU$[UnUR"U4SU0UD6$US:Xa[ S UUUS.UD6$US:Xa[ S UUUS.UD6$[ S US 35e) a1Loads 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. rrNrZronnx)r*r task_nameopenvinozUnsupported backend 'z6'. `backend` should be `torch`, `onnx`, or `openvino`.r?)r}_load_encoder_only_modelrnrr/r0r ) r)r*rrrr-rr model_clss rGrTransformer._load_modelds* g   T2#77556HaT`a$ L67GHI,,-?__R^_ _  "#5*    "&#5*  4WI=stu urFc b^^^S UUU4Sjjn[T[5(aSSKJn STlU"U5$[T[ 5(aSSKJn U"UTRSS9$[HAupxn [TU5(dM[[R"U5U 5n U"U 5s $ g) 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>[U4SS/0UD6 UR"T4SU=(d T0TD6sSSS5 $!,(df  g=f)N"_keys_to_ignore_on_load_unexpectedz decoder.*r)rr)r load_configextra_class_attrsrrr*s rG _load_encoder;Transformer._load_encoder_only_model.._load_encodersR*?JmO`!001CrKLa[areqrs 9 Ar)T5GemmaEncoderModelF)rz model.encoder)rbase_model_prefixr) rrOryr is_encoder_decoderrI.transformers.models.t5gemma2.modeling_t5gemma2rencoderrr importlib import_module) r)r*rrrr r config_cls module_path class_name encoder_clss ``` rGr$Transformer._load_encoder_only_models s s fm , , 8(-F % !45 5 fn - - V!fnn`op p4H /JZ&*--%i&=&=k&JJW $[114H rFc[URup4USSnURX5=nb]Uupx[US5(aEURb8SU;a20UR SSUS.5ESUR R0EUS'Xx4$URU5n [US5(aURbU RS5 URUR5n U bXZ;a;0nU H0n [SUS9n U S:XaUR RU S'XU 'M2 Xt4$URS :Xah0nU H\n U S:XaM S U S 3n [X5(dM#[X5nURU5nU(aS U;a U S S.X{'MUU SS.X{'M^ US 4$U V s0sH n U SUS._M sn U4$s sn f)aInfer the modality configuration and module output name from the model and processor. First checks :meth:`infer_modalities_edge_cases` for hard-coded overrides, then falls back to general inference based on the processor type and model forward signature. rpreNrrrqrsrjrZget_ _featuresrr)rxrinfer_modalities_edge_casesrrrr#rinfer_modalities_from_processorr_get_method_output_fieldsrqrhr)r)rrdefault_modality_configdefault_module_output_namedefault_method_output_nameresultrrra output_fieldsrwentryrrcmethod_output_fieldss rGr$Transformer.infer_modalitiess*?XX\XmXm>n;%$O.0O&&iLfgy(&*&:&:&I&IE(O,1) ' #> >  $8 8.0O&y( $XJi8 5..$U8F+/+I+I&+Q(+CW0W?Jbq4r1?Jbf4g1'#$88 8' & B\] ]&  && & s)F>c[RUR5nUcgURURR5nUcgUupVnU(dXV4$0nUR 5Hfup[ XS5(d#[RSU S<SU <S35 M;[XS5n U SURU SU 5S.X'Mh X4$)aReturn 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`. NrczModel does not have method z for modality z . Skipping.rers) rrrrrrrr  warning_oncer_infer_method_output_name) r)rrtask_edge_casesr  raw_configrvalidate_output_namesrrwr0rcs rGr'Transformer.infer_modalities_edge_casess699$:O:OP  "##ELL$;$;< =@E= (=$1 1*, * 0 0 2 H5"233##1&2B1E^T\S__jkU8$45F *&*&D&DVL`Eaci&j)O %!322rFcSSSSS.n[U[5(aEUR5=(d 0nUR5VVs/sHupEXC;dM UPM snn$[[ [ [S.nUR5HupW[X5(dMU/s $ [RS[U5RS35 /$s snnf) zWDetermine which modalities the processor supports by inspecting its attributes or type.rprrr)rimage_processorfeature_extractorvideo_processor)rprrrz6Could not determine modalities from processor of type z#. Returning an empty modality list.) rr#_get_processor_attributesrr"rr<rr r rrA)r)rprocessor_attribute_mappingprocessor_attributesprocessor_attributermodality_checksrs rGr+Transformer.infer_modalities_from_processor-s  &!(& < # i 0 0#'#A#A#C#Ir ;V:[:[:]:]6'&>:] ,+') 1  />.C.C.E *M)55%&/F DT)_E]E]D^_0 0  )s CCc[URS5(aURR5$[URS5(aURR$g)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)rrr5r6r4s rGr.%Transformer._get_processor_attributesPsM 4>>#3 4 4>>002 2 T^^\ 2 2>>,, ,rFc^U4Sjm[U5RSS5nT"U5nUcg[U5Vs/sHo3RPM sn$![a gf=fs snf)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. c>[U[5(a[U[5(aU$[ U5HnT"U5=ncMUs $ gr)rr issubclassr+r )type_annotationsub_annotationrfind_model_output_classs rGr=FTransformer._get_method_output_fields..find_model_output_classhsL/400ZQ\5]5]&&"*?";5nEEFR!M#<rFreturnN)r r Exceptionrr)rcreturn_annotation output_classfieldr=s @rGr%Transformer._get_method_output_fields]sq   .v 6 : :8T J //@A  (.|(<=(sAA% A"!A"cN[RU5=(d /nX;aU$g)a`Validate 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)rercrs rGr%%Transformer._infer_method_output_nameys($==fEK  .% %rFsafe_serializationcURRXS9 URRU5 URU5 g)z@Save the model, processor, and module config to ``output_path``.rGN)rsave_pretrainedr save_config)r) output_pathrHargsrs rGsaveTransformer.saves7 "";"V &&{3 %rFc  HURUUUUUUUUU U U S9 n U"SSU0U D6$)zWLoad a Transformer module from a pretrained model directory or Hugging Face model name.) r*rr cache_folderrrtrust_remote_coderrrrr*r?)_load_init_kwargs)rr*rrrQrrrRrrrrr init_kwargss rGloadTransformer.loadsP&++1%-/%-',  H&8HKHHrFc URUUUUUUS9n UUUUUUS.nSSSS.nUR5H2unnUU ;aU RU5U U'U RU05 M4 U SR U5 U SR U5 U SR U5 U(aU SR U5 U (aU SR U 5 U (aU SR U 5 0U ESU 0E$)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. )r*rrrQrr)rrrrrrRrrr) model_argstokenizer_args config_argsr)rrr} setdefaultrz)rr*rrrQrrrRrrrrrr hub_kwargs _OLD_TO_NEWold_namenew_names rGrSTransformer._load_init_kwargss/,1%- ! #% 0!2  )0* #."3"3"5 Hh6!#)::h#7x   h +#6 ~%%j1!"))*5&&z2  > " ) ), 7  % & - -.> ?  ? # * *= 9-&-)W--rFc |>U(aU/O/SQnUHn[TU]UUUUUUUS9n U (dM O SH(n U W ;dM SX;dMXRS5 M* SW ;a1Skn 0n U SR5HupSU ;aa[ U R S55nUVs/sH nUU ;dM UPM nnU(a [ RSU<S U <S 35 MfXU'MlX;a[ RS U <S 35 MXU 'M XS'U $URU 5uU S'U S 'U $s snf)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)r*rconfig_filenamerrQrr)rXrrYrrZrrRr>rprrrr+z%Ignoring unknown modality components z in modality_config key rzIgnoring unknown modality key z in modality_config.r) rrr}rrsplitr r _get_default_modality_config)rr*rrbrrQrrconfig_filenamesrrpvalid_single_modalitiesdeserialized_modality_configr/r0partspinvalidr's rGrTransformer.load_configs$   0OW(#5# /)!!1)Fv 0 Cf}!4 !C  34   &&T #+- ((./@(A(G(G(I$ ,&!,"4"4S"9:E*/T%Q1)J)E$ % GJFfFfgmFn CF$ %v.B'C -Us + D99D9c4[URSS5$)a[Get 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. rrZ)rxr)rs rGre(Transformer._get_default_modality_configHs)4FH\)]^^rFc,>[TU]5nURR5VVs0sHup#[ U5U_M snnUS'UR (dUR SS5 URcUR SS5 U$s snnf)zdReturn the config dict for serialization, with tuple modality keys joined as plus-separated strings.rrNr)rget_config_dictrrr2rr}r)r) config_dictrwr0r's rGrpTransformer.get_config_dictSsg-/ FJFZFZF`F`Fb* Fb2B(OH %v -Fb* %&%% OO/ 6    $ OOND 1* sBcvS[UR5URRRS9S3$)Nz Transformer() architecture))rrprr'rAr4s rG__repr__Transformer.__repr___s3d4#7#7#9 H\H\HeHefgghiirF)rrr3rr7rQrr#rrrrrrrrr)r*rbrTransformerTaskrdict[str, Any] | NonerryrryrzProcessingKwargs | Nonerz$Literal['torch', 'onnx', 'openvino']rzModalityConfig | Nonerrdr bool | Noner int | Nonerrrrdr?None)r?rz)rrzr?r|r?r)r?r{)rr{r?r|)r?r!)r?r )r?list[Modality])r?zPreTrainedTokenizerBase | Noner)rzlist[SingleInput | PairInput]rrdr?r)rrr?r)r?int) rwr5rzdict[str, list]rdict[str, dict[str, Any]]rrr?r)rzlist[list[MessageInput]]rrrrr?r)rrbr?r{)r*rbrrbrrr?z*tuple[PeftConfig | PretrainedConfig, bool]) r*rbrzfLiteral['feature-extraction', 'sequence-classification', 'text-generation', 'any-to-any', 'fill-mask']rzPeftConfig | PretrainedConfigrrbr-rr?r!)r*rbrr r?zPreTrainedModel | None)rr!rzmProcessorMixin | PreTrainedTokenizerBase | FeatureExtractionMixin | BaseVideoProcessor | ImageProcessingMixinr?tuple[ModalityConfig, str])rr!rXProcessorMixin | PreTrainedTokenizerBase | FeatureExtractionMixin | ImageProcessingMixinr?z!tuple[ModalityConfig, str] | None)rrr?r~)r?list[str] | None)rcrr?r)rerbrcrr?rd)rLrbrHrr?r|) rNNNFFNNNr)r*rbrrbrbool | str | NonerQrdrrdrrrRrrryrryrryrrbr?r;)r*rbrrbrrrQrdrrdrrrRrrryrryrryrrbr?r)rNNNNF)r*rbrrbrbrdrrrQrdrrdrrr?r)rrr?r)r?r)r?rb)0rArBrCrDrlrrfrrr9rpropertyrsetterr8rr\rrarrrqrrrrrrrrrr$rrr. staticmethodrr%rN classmethodrUrSrrerprvrE __classcell__)r's@rGrrsUn8c7KL$! -A.226/3598?15)-$(%)#-1a)a)* a) , a) 0 a)-a)3a)6a)/a)'a)"a)#a)a)!+a) !a)"a)F " "  EN 44 !!11::"r -r r  r h]~3 j$p$p*$p3 $p & $p  $pL    *  3  &    D  * 3  &    B@ *@ 3@ & @  @ D,&V"%&V03&VDR&V 3&VP2v2v 2v . 2v2v2v 2vh''!' 'RC&C&C& $C&J%3%3l%3 + %3N!k! !F >>6  HL&  #'#'#!&"'.226/3II I ! I ! III I,I0I-II !IIB #'#'#!&"'.226/3B.B. B. ! B. ! B.B.B. B.,B.0B.-B.B. !B.B.H&*#'#'#!&RRR$ R ! R ! RRR RRh__ jjrFrr})rzlist[list[dict[str, Any]]]r?ztuple[list[int], list[int]])t __future__rrrcollections.abcr contextlibr dataclassesrtypingrrr r r r rpackaging.versionr parse_versiontokenizers.normalizersrrryrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*transformers_versiontransformers.utilsr+r,transformers_loggingtransformers.utils.import_utilsr-transformers.utils.peft_utilsr.sentence_transformers.backendr/r0#sentence_transformers.base.modalityr1r2)sentence_transformers.base.modality_typesr3r4r5r6r7/sentence_transformers.base.modules.input_moduler8%sentence_transformers.util.decoratorsr9&sentence_transformers.util.environmentr:r;rtyping_extensionsr<rIrJrOrRrUrrY get_loggerrAr rrrxr`rhrModalityConfigrnrfrorxrrrr_TEXT_GENERATION_EDGE_CASES_ANY_TO_ANY_EDGE_CASESrrrrrrr?rFrGrs"$%SS 468=*>=BNOHNM' / ? * , .&((  ( ( 23@AU3VYfgoYp3p0@MNb@cgthA=a #i# *,E*h./$A+% > : 5 !#<0 I=PQR IXFG  IXFG IXFG IXFG#PL4~/0 12!34!34>#78~':;~/OPKM`aH  A?SBDTUGIZ[HJ\]BDTU?QIK\]-51>&=PQ&/GZ[ <8hO 2/Z 4O\*C[jk   hO 2J]^ 4L_`   hO& 2J]^ 5M`a    'hO6 2/Z 4O\   7hOH (@ST*3K^_    IhOX(@ST*3K^_   YhOj yH[\] khOt yH[\] uhO~ yH[\] hOH yH[\]  IhOT )ATU*3K^_   UhOf(@ST )ATU*3K^_  ghOz ${hO|'}hO~ !hO@ #AhOB+ChOD(&0 #%.OhO KhZ  J    FB  )I*38T     yI   0 )I*38T     yQR   yQR  yQR  yQR !*J*38T   A(V92(& WS&& "y " ":Aj+AjC '&&'                       h  s~ M0NN"N;)O0O)1 P0 N?NNNN87N8;OOO&%O&)O=<O=P  P