tj6ddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z ddl mZddlmZddlmZddlmZmZmZddlZddlZddlmZddlZddlmZmZdd l m!Z!dd lm"Z"m#Z#dd lm$Z$m%Z%m&Z&dd l'm(Z(dd l)m*Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1m2Z2ddl3m4Z4m5Z5m6Z6ddl7m8Z8m9Z9ddl:m;Z;mm?Z?ddl@mAZAmBZBmCZCmDZDmEZEddlFmGZGerddlmHZHe+jIeJZKGdde#jLe?e ZMdS)) annotationsN)ABCabstractmethod) OrderedDict)Queue)Path) TYPE_CHECKINGAnyLiteral)CardDataHfApi)version)Tensornn)PreTrainedModelis_datasets_availableis_torch_npu_available)get_relative_import_files)logging) __version__) BaseEvaluator)infer_batch_modality raise_unsupported_modality_error)Modality PairInput SingleInput)BaseModelCardDatagenerate_model_card)ModuleRouter Transformer)PeftAdapterMixin)get_device_nameimport_module_class load_dir_pathload_file_pathsave_to_hub_args_decorator)ORIGINAL_TRANSFORMER_MODELS)PretrainedConfigc4eZdZUdZeZdZded<iZded<dZ ded <ded < ddddddd dd dddddd d dfd&Z dd'Z dd*Z dd+Z edd-Zdd0Zdd2Zdd4Zdd6Zdd7Zdd8Zedd;Zedd=Zdd@ZdfdA Z dddEZddHZddJZ dddRZddTZ dddUZ ddWZ! dddYZ"e# dddcZ$ dddeZ% dddgZ&e' dddhZ( dddiZ)ddkZ* dddlZ+ dddmZ, dddpZ-ddduZ.dddwZ/eddyZ0 ddd|Z1edd~Z2dZ3eddZ4eddZ5e5j6ddZ5eddZ7eddZ8e8j6ddZ8eddZ9eddZ:e:j6ddZ:eddZ;e;j6dddZ;eddZddZ?xZ@S) BaseModela Base class for SentenceTransformer, SparseEncoder, and CrossEncoder models. This class provides common functionality for: - Model loading (from Hub, local paths, or creating new models) - Model saving (to disk and Hub) - Device management - Module architecture (sequential composition) - Configuration management - Tokenizer/processor access All models inherit from nn.Sequential and are composed of a sequence of modules that are called sequentially in the forward pass. N str | None default_huggingface_organizationzdict[str, str | None]_default_promptssentence_transformers_model_idstr _model_card_model_id_placeholder model_typeFtorch)modulesdevicepromptsdefault_prompt_name cache_foldertrust_remote_coderevisionlocal_files_onlytoken model_kwargsprocessor_kwargs config_kwargsmodel_card_databackendmodel_name_or_pathr44list[nn.Module] | OrderedDict[str, nn.Module] | Noner5r6dict[str, str] | Noner7r8r9boolr:r;r<bool | str | Noner=dict[str, Any] | Noner>r?r@CardData | NonerA$Literal['torch', 'onnx', 'openvino']returnNonec t|j}|r||||_||_||_|p|| |_d|_i|_ d|_ ||_ |tj d}|dkr|r| pidnd}|du}|.|,t}t d|n|r|t d|dkr/t&jd d d lm}||rtj|stj|rt7d |d tjdkrd|vs|ddkrt=d |d|j+d|vr'| tBvr |jd|}|r&|"|| |||| | | |  \}|_|;tG|tHs&tIdtK|D}|8tM|d kr%tOdtQ|j)dtU+|tY|d -d}|H|j.}t_|0ddD]}|1||I|j2}t_|0ddD]}|1|n|1|d|_3|4|j5|dS)a Initialize a BaseModel instance. Args: model_name_or_path (str, optional): If a filepath on disk, loads the model from that path. Otherwise, tries to download a pre-trained model. If that fails, tries to construct a model from the Hugging Face Hub with that name. Defaults to None. modules (list[nn.Module], optional): A list of torch modules that are called sequentially. Can be used to create custom models from scratch. Defaults to None. device (str, optional): Device (like ``"cuda"``, ``"cpu"``, ``"mps"``, ``"npu"``) that should be used for computation. If None, checks if a GPU can be used. If a ``device_map`` is provided via ``model_kwargs``, that controls device placement and this argument is ignored. Defaults to None. prompts (dict[str, str], optional): A dictionary with prompts for the model. The key is the prompt name, the value is the prompt text. The prompt text will be prepended before any text during inference. For example: ``{"query": "query: ", "passage": "passage: "}``. If a model has saved prompts, you can override them by passing your own, or pass ``{"query": "", "document": ""}`` to disable them. Defaults to None. default_prompt_name (str, optional): The name of the prompt that should be used by default. If not set, no prompt will be applied. Defaults to None. cache_folder (str, optional): Path to store models. Can also be set by the ``SENTENCE_TRANSFORMERS_HOME`` environment variable. Defaults to None. trust_remote_code (bool, optional): Whether to allow for custom models defined on the Hub in their own modeling files. Only set to ``True`` for repositories you trust and in which you have read the code, as it will execute code present on the Hub on your local machine. Defaults to False. revision (str, optional): The specific model version to use. It can be a branch name, a tag name, or a commit id, for a stored model on Hugging Face. Defaults to None. local_files_only (bool, optional): Whether to only look at local files (i.e., do not try to download the model). Defaults to False. token (bool or str, optional): Hugging Face authentication token to download private models. Defaults to None. model_kwargs (dict[str, Any], optional): Keyword arguments passed to the underlying Hugging Face Transformers model via ``AutoModel.from_pretrained``. 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 (useful when serving multiple models in one process). When set, it takes precedence over the ``device`` argument. - ``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 passed to the Hugging Face Transformers processor/tokenizer via ``AutoProcessor.from_pretrained``. See the `AutoTokenizer.from_pretrained `_ documentation for more details. Defaults to None. config_kwargs (dict[str, Any], optional): Keyword arguments passed to the Hugging Face Transformers config via ``AutoConfig.from_pretrained``. See the `AutoConfig.from_pretrained `_ documentation for more details. Defaults to None. model_card_data (CardData, optional): A model card data object that contains information about the model. Used to generate a model card when saving the model. If not set, a default model card data object is created. Defaults to None. backend (str, optional): The backend to use for inference. Can be ``"torch"`` (default), ``"onnx"``, or ``"openvino"``. Defaults to ``"torch"``. )r;NSENTENCE_TRANSFORMERS_HOMEr3 device_mapzNo device provided, using zBoth `device` and `model_kwargs['device_map']` were provided. `device_map` controls device placement, so the `device` argument is ignored.hpuoptimumr)adapt_transformers_to_gaudizPath z is a file, not a directory. `model_name_or_path` must be a local directory containing a model, or a Hugging Face Hub model ID.\/z not foundr<r8r:r9r;r=r>r?c6g|]\}}t||fS)r0).0idxmodules ^/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/sentence_transformers/base/model.py z&BaseModel.__init__..s'"\"\"\+#vCHHf#5"\"\"\z$An empty modules list was passed to z@. Please provide at least one module, e.g. a Transformer module.F)6dictr.updater6r7r9model_card_data_classr@ module_kwargs_model_card_vars_model_card_textrAosgetenvgetr#loggerinfowarning importlibutil find_spec*optimum.habana.transformers.modeling_utilsrQpathisdirisfileNotADirectoryErrorsepcountFileNotFoundErrorr-lowerr( _load_modules isinstancer enumeratelen ValueErrortype__name__super__init__next parametersdtypelistchildrentor5is_hpu_graph_enabled_validate_promptsregister_model)selfrBr4r5r6r7r8r9r:r;r<r=r>r?r@rAdefault_promptsrNdevice_providedrQ first_param first_dtyperZbackbone_device __class__s r[r~zBaseModel.__init__Qs`pt455  ,  " "7 + + +& #6 !2.o$2L2L^n2L2o2o! " $  9%ABBLAH7@R@RWi@Rl(b--l;;;pt  , >j0$&&F KK=V== > > > >  !7 NNI    U??y~77 BBN ^ ^ ^ ^ ^ ^ ' ' ) ) )  ebgmm4F&G&G ew~~011 ([.[[[ $4+=#=#=BTBZBZ[^B_B_bcBcBc'(N0B(N(N(NOOO5A111&,,..6QQQ(,(M%d%dPb%d%d"  *.*<*<")!"3!1)!1++= + + 'GT'  z';'G'G !"\"\SZI[I["\"\"\]]G  3w<<1#4#4QtDzz7JQQQ  !!! 47--//66  "%+Kt}}//3 ' ' +&&&&  !#kOt}}//3 + + /**** + GGFOOO$)!     ++D11111r]c |jD]\}}| d|j|<|jM|j|jvr?td|jdt |jdd|jDx}r:t |}td|d|d krd ndd ||jr%t d |jd dSdS)z9Validate prompt configuration and log prompt information.NzDefault prompt name ';' not found in the configured prompts dictionary with keys .c$g|] \}}|dk |S)rrWrXkvs r[r\z/BaseModel._validate_prompts..s!LLLDAqAGGaGGGr]zLoaded z promptrTsz with these keys: zDefault prompt name is set to 'zs'. This prompt will be applied to all inference calls, except if a `prompt` or `prompt_name` parameter is provided.) r6itemsr7rzrkeysryrgrh warning_once)rkeyvaluenon_empty_keysns r[rzBaseModel._validate_promptssk,,,.. ' 'JC}$& S!  # /D4LTXT`4`4`G(@GG(,T\->->-@-@(A(AGGG  MLDL,>,>,@,@LLL L> fN##A KKd!dd1q55CCbddTbdd e e e  #    F$2JFFF       r]prompt prompt_namec D||W |j|}n#t$r;td|dt|jdwxYw|j |j|jd}n|td|S)a&Resolve a prompt from a prompt name or the default prompt name. Args: prompt: An explicit prompt string, or None. prompt_name: A key into ``self.prompts``, or None. Returns: The resolved prompt string, or None if no prompt applies. Nz Prompt name 'rrzvProvide either a `prompt`, a `prompt_name`, or neither, but not both. Ignoring the `prompt_name` in favor of `prompt`.) r6KeyErrorrzrrr7rfrgri)rrrs r[_resolve_promptzBaseModel._resolve_prompt$s >&!\+6FF$O OOptuyvBvGvGvIvIqJqJOOO)5))$*BDII  $ NNC    s AAc|jS)zReturn the backend used for inference, which can be one of "torch", "onnx", or "openvino". Returns: str: The backend used for inference. )rArs r[ get_backendzBaseModel.get_backend?s |r]list[Modality]c2t|dddgS)zmReturn the list of modalities supported by this model, e.g. ``["text"]`` or ``["text", "image", "message"]``.r modalitiestextgetattrrs r[rzBaseModel.modalitiesGstAw vh777r]modalityrc|j|vrdSt|trdvrtfd|DSdS)aCheck if the model supports the given modality. A modality is supported if: 1. It is directly listed in :attr:`modalities` (including tuple modalities that are explicitly listed), or 2. It is a tuple of modalities (e.g. ``("image", "text")``) where each part is individually supported and the model also supports ``"message"`` format, which is used to combine multiple modalities into a single input. Args: modality: A single modality string (e.g. ``"text"``, ``"image"``) or a tuple of modality strings (e.g. ``("image", "text")``). Returns: bool: Whether the model supports the given modality. Example:: >>> from sentence_transformers import SentenceTransformer >>> model = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2") >>> model.supports("text") True >>> model.supports("image") False Tmessagec3 K|]}|vV dSNrW)rXpart supporteds r[ z%BaseModel.supports..ks(>>Tty(>>>>>>r]F)rrwtupleall)rrrs @r[supportszBaseModel.supportsLs`6O y 4 h & & ?9 +A+A>>>>X>>>>> >ur] list[str]c2t|}t}|r|\}}t |t rP|jD]6}|t|7|j r)||j vr | |j |t|dr| |j |t|S)a Get the keyword arguments specific to this model for inference methods like `encode` or `predict`. Example: >>> from sentence_transformers import SentenceTransformer, SparseEncoder >>> SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2").get_model_kwargs() [] >>> SentenceTransformer("jinaai/jina-embeddings-v4", trust_remote_code=True).get_model_kwargs() ['task', 'truncate_dim'] >>> SparseEncoder("opensearch-project/opensearch-neural-sparse-encoding-doc-v3-distill").get_model_kwargs() ['task'] Returns: list[str]: A list of keyword arguments for the forward pass. forward_kwargs) rnamed_childrensetpoprwr sub_modulesvaluesextendrar_hasattrr)rr4r module_namerZ route_moduless r[get_model_kwargszBaseModel.get_model_kwargsns"t**,,-- =")++-- K&&)) I%+%7%>%>%@%@IIMNN4 (D(D(F(F#G#GHHHH! GkT5G&G&G%%d&8&EFFFv/00 =%%f&;<<< =N###r] int | Nonec|jS)a_ .. deprecated:: Use the :attr:`max_seq_length` property instead. Returns the maximal sequence length that the first module of the model accepts. Longer inputs will be truncated. Returns: Optional[int]: The maximal sequence length that the model accepts, or None if it is not defined. max_seq_lengthrs r[get_max_seq_lengthzBaseModel.get_max_seq_lengths ""r]torch.nn.ModulecZ|jtt|jS)z4Returns the first module of this sequential embedder)_modulesriterrs r[ _first_modulezBaseModel._first_modules!}T$t}"5"56677r]cZ|jtt|jS)z3Returns the last module of this sequential embedder)rrreversedrs r[ _last_modulezBaseModel._last_modules!}T(4="9"9::;;r]ct|d}t|tr|jSt|tr~|jD]P}t t|d}t|tr|jsdSQt|jSdS)aCheck if the first module (Transformer or Router containing Transformers) supports flattened text-only inputs. For Router models, this returns True only if ALL routes support flattening, since we cannot know at this point which route will be used. rNF) rwr!can_flatten_inputsr rrrrrrE)r input_moduleroutefirst_in_routes r[_can_flatten_inputszBaseModel._can_flatten_inputss Aw lK 0 0 32 2 lF + + 2%188:: ! !!%d5>>+;+;&<&>!nFg! 55! 011 1ur] sorted_idx np.ndarrayct|}tj||j}|d|dzdz|ddd<||dz |dz dzd|ddd<|S)aJInterleave a largest-to-smallest sorted index array so that each consecutive batch contains a mix of long and short inputs. When text-only inputs are flattened via flash attention, there is no padding. Total tokens per batch equals the sum of actual lengths. Grouping all long inputs together creates peak-memory batches, while grouping all short inputs together under-utilises the GPU. Interleaving (largest, smallest, 2nd largest, 2nd smallest, ...) balances the total token count across batches for more uniform memory usage. )rNrTr)rynpemptyr)rr interleaveds r[_interleave_sorted_indicesz$BaseModel._interleave_sorted_indicessu  OOhq (8999 &~!a%A~6 ADqD&q1uA!|b'@A ADqDr]intc`t|trt|St|ttfr@|r>t|dt r d|dvst d|DSt|t rd|vr t|dSd|vr\|d}t|trt|St|trt d|DSdSt d| DSt|tr6|r4t|dt rt d |DSt|tj tj fr5t|tj r|n|jS dd lm}t||r|jd|jdzSn#t$$rYnwxYwdS) zEstimate the "size" of an input sample for length-based batch sorting. The exact value doesn't matter, it's only used to group similarly sized inputs together so that padding waste is minimised within each batch. rrolec3JK|]}t|VdSrr+ _input_length)rXrs r[rz*BaseModel._input_length..s0FF!922155FFFFFFr]arraycontentc 3K|]I}t|ttt|ddVJdS)rrN)rwr^ryr0rf)rXitems r[rz*BaseModel._input_length..sRll$U_`dfjUkUkls3txx';';#<#<==llllllr]rTc3JK|]}t|VdSrr)rXrs r[rz*BaseModel._input_length..s0KKay..q11KKKKKKr]c3JK|]}t|VdSrr)rXmsgs r[rz*BaseModel._input_length..s0FFy..s33FFFFFFr])Image)rwr0ryrrr^sumr+rrrndarrayr3rnelementsize PIL.Imager ImportError)samplerPILImages r[rzBaseModel._input_lengthsM fc " " v;;  fudm , , G Gz&)T:: GvPQ?R?RFFvFFFFFF fd # # L&   ..vg???F"" +gs++(w<<'gt,,mll'llllllqKK6==??KKKKK K fd # # G G:fQi3N3N GFFvFFFFF F frz5<8 9 9 Z(265<(H(HY6??$$$fk Y  3 3 3 3 3 3&(++ 7{1~ A66 7    D qs,0H H+*H+inputdict[str, Tensor]c |D]m\}i}ttr|}nEg|j|j|gfd|D}|fi|}n|S)z.Forward pass through all modules in the model.NcVi|]%\}}|vstd|jv"||&S)r)rr)rXrrrZmodule_kwarg_keyss r[ z%BaseModel.forward..sT!!!"U///GFDT4U4U/Z]agavZvZvZvZvZvr])rrwr rarfr)rrkwargsrrarZrs @@r[forwardzBaseModel.forwards#'#6#6#8#8 3 3 KM&&))  & $&!%1(,(:(>(>{B(O(O%!!!!!&,llnn!!! F522M22EE r]c6tj|i|S)aG Compile the model's forward pass with :func:`torch.compile` to speed up inference. All arguments are forwarded to :func:`torch.compile`. Inference (e.g. ``encode()`` or ``predict()``) runs the forward pass by calling the model, so compiling the model speeds up these calls. .. tip:: Pass ``dynamic=True`` for inputs with variable sequence lengths, so one compiled kernel handles any length. Explicit ``dynamic=False`` recompiles the model for every new sequence length, which adds significant overhead. )r}compile)rargsrrs r[rzBaseModel.compiles uww////r]inputslist[SingleInput | PairInput]dict[str, Tensor | Any]c `|siSd} t||j}n#ttf$rYnwxYw|A||s,t |||jt |jd |dj|fdi|}n#t$r-r|dkrfd|D}|dj|fi|}Ynft$rZr|dkrfd|D} |dj |fi|}n+#t$r|d |}YnwxYwYnwxYw|S) a Preprocesses the inputs for the model. Args: inputs (list[SingleInput | PairInput]): A list of inputs to be preprocessed. Each input can be a string, dict, tuple, PIL Image, numpy array, torch Tensor, or other supported modality. If a single input is provided, it must be wrapped in a list. prompt (str, optional): A prompt string to prepend to text inputs. Defaults to None. If the model supports the ``message`` modality, the prompt will be added as a system message to the input messages instead of being prepended to text. **kwargs: Forwarded to the input module's ``preprocess``. For :class:`~sentence_transformers.base.modules.Transformer` input modules this notably includes ``processing_kwargs``, which overrides the processor kwargs configured on the module for this call only (see :meth:`Transformer.preprocess `). Returns: dict[str, Tensor | Any]: A dictionary of tensors with the preprocessed inputs. N)supported_modalities modelrrrcrg|]3}t|tr|dzf|ddzn|z4SrrTNrwrrXinprs r[r\z(BaseModel.preprocess..EMuuugj*S%:P:Pb6CF?,s122w66V\_bVbuuur]crg|]3}t|tr|dzf|ddzn|z4Sr r r s r[r\z(BaseModel.preprocess..Ir r]) rrrz TypeErrorrrr{r| preprocessAttributeErrortokenize)rrrrr preprocesseds ` r[rzBaseModel.preprocesss0 I  +FYYYHHI&    D    h(?(?  ,VXtSWX\S]S]SfPnPnPn o o o 8-47-fNNVNvNNLL @ @ @ v(f,,uuuuntuuu-47-f????LLL 8 8 8 v(f,,uuuuntuuu 8/tAw/AA&AA  8 8 8#Aw//77  8  8sH 44;B4D+D+(C=<D+=%D%"D+$D%%D+*D+texts.list[str] | list[dict] | list[tuple[str, str]]c Ttd|jdd|i|S)za .. deprecated:: `tokenize` is deprecated. Use `preprocess` instead. zEThe `tokenize` method is deprecated, please use `preprocess` instead.rrW)rgrr)rrrs r[rzBaseModel.tokenizeQs6 cdddt66e6v666r]r cttf}tr ddlm}||fz }n#t $rYnwxYwt ||rdSt |tjr|j dkr|j j dvrdSdS)z Check if the input represents a single example or a batch of examples. Args: inputs: The input to check. Returns: bool: True if the input is a single example, False if it is a batch. r)ColumnFrT)UOT) rrrdatasetsrrrwrrndimrkind)rr list_typesrs r[is_singular_inputzBaseModel.is_singular_inputZsE] " "  ++++++vi'      fj ) ) 5 fbj ) ) fkQ.>.>6dh Ifd1 = = = = > > > > > > > > > > > > > > >#4=11' 1' 1IC!]40FqWV^<<ATW\\$33 W\\$C3fAV0VWW K T 2 2 2 2 ( J;M NNNN ( ( ( J''''' (V /I##$;<< C [3< !,,Z0@0@0EF  J 222$=Z#H#H88K $Z 0 0D4E4E4J KIK Y7777 )s33B7QQ$v,,:OQQ (BB4<<+@BB $'rw?O?OPZ?[?[enooM! 8dd.@&@&@W[WijnWoFom&@*7 h'  ! !- 0 0 0 0 "',,t^44cF K K K 6t Ind1 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6  F  # #D*n E E E E E F Fs6>B##B'*B'/FF)(F) M//M36M3dict[str, Any]ch|jttjtjd|j|jdS)N)sentence_transformers transformerspytorch)r2rr6r7)r2rrQr3r6r7rs r[r5zBaseModel._get_model_configs</)4 , 8 , |#'#;   r]c:||||||dS)r&r r!r"r$N)r:)rrnr r!r"r$s r[save_pretrainedzBaseModel.save_pretraineds8& !/)1      r] model_cardc|jjrG|d|jjd|jdd|jjd|jjd}|S)z.Update the default model ID in the model card.zmodel = z("")r@model_idreplacerr|r1)rrVs r[_update_default_model_idz"BaseModel._update_default_model_idsl   ( #++^4>2^^d6[^^^V4>2VVd6J6SVVVJr] deprecatedcZ|r;t|}|s|jjs ||j_||j_|jr+d|jjvr|j}||}nQ t|}n@#t$r3t dtj dYdSwxYwttj|ddd5}||ddddS#1swxYwYdS) a Create an automatic model card and store it in the specified path. Args: path (str): The path where the model card will be stored. model_name (Optional[str], optional): The name of the model. Defaults to None. train_datasets (Optional[List[str]], optional): Deprecated argument, ignored. Returns: None generated_from_trainerz#Error while generating model card: zConsider opening an issue on https://github.com/huggingface/sentence-transformers/issues with this traceback. Skipping model card creation.N README.mdr*r+r,)rexistsr@rYsave_dirrctagsr[r Exceptionrgerror traceback format_excr6rdrnr7write)rrnr r"rHrVrGs r[rDzBaseModel._create_model_cards  ;j))J$$&& ;t/C/L ;0:$-)-%  %=TEYE^%^%^.J66zBBJJ 066     49;O;Q;Q444   "',,t[113 H H H #D JJz " " " # # # # # # # # # # # # # # # # # #s$=B 9C  C =D  D$'D$Add new model.repo_id organizationprivate bool | Nonecommit_messagelocal_model_pathr(replace_model_cardc htd|ryd|vr)td|d|d|d|}nL|dd|krtdtd|d||||||||| |  S)aY DEPRECATED, use `push_to_hub` instead. Uploads all elements of this model to a new HuggingFace Hub repository. Args: repo_id (str): Repository name for your model in the Hub, including the user or organization. token (str, optional): An authentication token (See https://huggingface.co/settings/token) private (bool, optional): Set to true, for hosting a private model safe_serialization (bool, optional): If true, save the model using safetensors. If false, save the model the traditional PyTorch way commit_message (str, optional): Message to commit while pushing. local_model_path (str, optional): Path of the model locally. If set, this file path will be uploaded. Otherwise, the current model will be uploaded exist_ok (bool, optional): If true, saving to an existing repository is OK. If false, saving only to a new repository is possible replace_model_card (bool, optional): If true, replace an existing model card in the hub with the automatically created model card train_datasets (List[str], optional): Datasets used to train the model. If set, the datasets will be added to the model card in the Hub. Returns: str: The url of the commit of your model in the repository on the Hugging Face Hub. zThe `save_to_hub` method is deprecated and will be removed in a future version of SentenceTransformers. Please use `push_to_hub` instead for future model uploads.rSzQProviding an `organization` to `save_to_hub` is deprecated. Please use `repo_id="z "` instead.rzYProviding an `organization` to `save_to_hub` is deprecated. Please use `repo_id` instead.) rir<rkr$rmrnr(ror")rgrirArz push_to_hub) rrirjr<rkr$rmrnr(ror"s r[ save_to_hubzBaseModel.save_to_hubsB  J    '!!LhtLLw~LLL*55G55s##A&,66 o|ho|||1)-1)   r] create_prc t|} | ||d|p| } | j}|j|| | || d|>|}|dkrd|jjd}nd|jjd |d }d }| r(d |jjd |d| |}|r | |||| r|nd| | }ntj 5}|rd}ni t|d|| d}|du}nO#t$rB}td|dt#|jd|dd}Yd}~nd}~wwxYw||||| || |||| r|nd| | }dddn #1swxYwY| r)td|j|jS|jS)az Uploads all elements of this model to a HuggingFace Hub repository, creating it if it doesn't exist. Args: repo_id (str): Repository name for your model in the Hub, including the user or organization. token (str, optional): An authentication token (See https://huggingface.co/settings/token) private (bool, optional): Set to true, for hosting a private model safe_serialization (bool, optional): If true, save the model using safetensors. If false, save the model the traditional PyTorch way commit_message (str, optional): Message to commit while pushing. local_model_path (str, optional): Path of the model locally. If set, this file path will be uploaded. Otherwise, the current model will be uploaded exist_ok (bool, optional): If true, saving to an existing repository is OK. If false, saving only to a new repository is possible replace_model_card (bool, optional): If true, replace an existing model card in the hub with the automatically created model card. If false (default), keep the existing model card if one exists in the repository. train_datasets (List[str], optional): Datasets used to train the model. If set, the datasets will be added to the model card in the Hub. revision (str, optional): Branch to push the uploaded files to create_pr (bool, optional): If True, create a pull request instead of pushing directly to the main branch Returns: str: The url of the commit of your model in the repository on the Hugging Face Hub. )r<N)rirk repo_typer(T)ribranchr(r3zAdd new rz model with an z backendrzBHello! This pull request has been automatically generated to add z1 compatibility. ## Full Model Architecture: ``` z ``` )ri folder_pathrmcommit_descriptionrsr:r_F)r<r:r;z-Could not check for an existing README.md on  (: zG). Skipping model card creation to avoid overwriting any existing card.rTz#A pull request has been created at )r create_reporir@ set_model_id create_branchrrr|_push_to_hub_usage_tip upload_foldertempfileTemporaryDirectoryr&rcrgrir{r:rhpr_url commit_url)rrir<rkr$rmrnr(ror"r:rsapirepo_urlrArx folder_urltmp_dircreate_model_card_for_pathexisting_readmeexcs r[rqzBaseModel.push_to_hub\sKF%   ??* #   " ))'222     gh  N N N  !&&((G'!!!KDN,C!K!K!K!eDN,C!e!eT[!e!e!e  * "*<@>;R "* "* "* "*W%% "* "*  * **,-9B#L#5#5#! +JJ,.. '%;15.. ;*8#[ch+++6E5L22$;;;cGccY]^aYbYbYkccorccc6;222222 ;  &&@#1'9 !..# '#1=F'P'9'9D'% / 3               D  % KKQj>OQQ R R R$ $$$s<F<D('F<( E428E/*F</E44r? load_kwargsmodules_json_pathmodel_type_being_loadeds r[rvzBaseModel._load_modulessz( !2 0( 0*   +  %-      $ KKv5Gvv^b^mvvv w w w-4-.@PPKPP P"&"6"6 %- #7# #  #do 5 5 KKU4?UU@RUUU V V V,4,-?OO;OO O l"9llBTllZ^Zilllmmm+t+,>rr+rrZqrrrrr]c dS)a Args: model_name_or_path (str): The name or path of the pre-trained model. token (Optional[Union[bool, str]]): The token to use for the model. cache_folder (Optional[str]): The folder to cache the model. revision (Optional[str], optional): The revision of the model. Defaults to None. trust_remote_code (bool, optional): Whether to trust remote code. Defaults to False. local_files_only (bool, optional): Whether to use only local files. Defaults to False. model_kwargs (Optional[Dict[str, Any]], optional): Additional keyword arguments for the model. Defaults to None. processor_kwargs (Optional[Dict[str, Any]], optional): Additional keyword arguments for the processor/tokenizer. Defaults to None. config_kwargs (Optional[Dict[str, Any]], optional): Additional keyword arguments for the config. Defaults to None. Returns: List[nn.Module]: A list containing the transformer model and the pooling model. NrW) rrBr<r8r:r9r;r=r>r?s r[rzBaseModel._load_default_modulessr]c t|d||||} | t| d5} tj| } dddn #1swxYwYd| vrwd| dvrmt j| ddt jt kr2td| ddd t d | |  t|d ||||} nO#t$rB}td |d t|j d|dd} Yd}~nd}~wwxYw| T t| d5} | |_dddn #1swxYwYn#t$rYnwxYwt|d||||}t|d5} tj| }dddn #1swxYwYt}t}|D]}|d}|||||||||}t#j|j}t'|jdkr t#j|j}t-|j}hd|z}ddh|k}|s|rt/j||d|||||||| |j }dddd}|r8|s6|D]!\}}||vr||||<"ddh}|D]}||vr||vr|| ||fi|} n\t9||d||||}!||!} n+|||d|||||||| |j } | ||d <|d!g||d <|ot=|}"t'|"jd"krHt=|jd#}#t'|#d$krtAd%|#Dr|#}|s|j!"||&||fS)'a Loads a full model using the modules.json file. Args: model_name_or_path (str): The name or path of the pre-trained model. token (Optional[Union[bool, str]]): The token to use for the model. cache_folder (Optional[str]): The folder to cache the model. revision (Optional[str], optional): The revision of the model. Defaults to None. trust_remote_code (bool, optional): Whether to trust remote code. Defaults to False. local_files_only (bool, optional): Whether to use only local files. Defaults to False. model_kwargs (Optional[Dict[str, Any]], optional): Additional keyword arguments for the model. Defaults to None. processor_kwargs (Optional[Dict[str, Any]], optional): Additional keyword arguments for the processor/tokenizer. Defaults to None. config_kwargs (Optional[Dict[str, Any]], optional): Additional keyword arguments for the config. Defaults to None. Returns: Tuple[OrderedDict[str, nn.Module], OrderedDict[str, Any]]: An ordered dictionary containing the modules of the model and their kwargs. r)rNr+r,rrPz:This model was created with Sentence Transformers version z, but you're using version zD. Consider updating to the latest version to avoid potential issues.r_zCould not fetch README.md from ryrzz(). Model will load without a model card.r3r{)r<r8r;rT> model_args config_argstokenizer_argsr=r?rn) subfolderr<r8r:r;r9r=r>r?rArrr)r=r>r?modality_configmodule_output_name)rBrr<r8r:r;r2rr(c3K|]}|dvV dS)0123456789abcdefNrW)rXcs r[rz1BaseModel._load_config_modules..s)8m8mUV>P9P8m8m8m8m8m8mr])r:)#r&r6r8loadrparserrgri_parse_model_configrcr{r|readrcr_load_module_class_from_refinspect signatureryrr~rr!_load_init_kwargsrArrr%rfrpartsrr@set_base_model)$rrBr<r8r:r9r;r=r>r?&config_sentence_transformers_json_pathfIn model_configmodel_card_pathrrrEr4rarMrI module_classload_signaturer init_paramsuses_old_namesuses_new_names init_kwargsnew_to_old_name_mappingnew_nameold_nameoptional_paramsrZ local_path path_partsrevision_path_parts$ r[rzBaseModel._load_config_modules"s<2@  /%- 2 2 2 . 2 =U"VWWZaZghsZtZtttBQ]^kQlnERFBB0;BBB  $ $\ 2 2 2 #,")!!1 OO # # # NN82D88$s))J\88`c888   #OOOOOO  #  & /F;;;7s,/HHJJD)777777777777777    +  %-    #f 5 5 5 ,!Ys^^N , , , , , , , , , , , , , , ,--# +` S` SM%f-I#'#C#C"!)!1$D $ $L%.|/@AAN>,--22#-l.CDD ")"677 !P!P!PS^!^"0/!Bk!Q!0;^0;"-"?*"/"7#%1!))9*;%1)9&3 $ ###K$)5,<)6//+ &RnR2I2O2O2Q2QRR.Hh';668C8Q8Q H 5(9:N&OO$366#{22x{7R7R'OOH555)\*<LL LLFF "/+="/"7#%1!))9 """J*..z::FF &**&+F3!-%%5&7!-%5"/ L+ .4GM&) *3@3D3DXr3R3RM-/ 0 0  /00J:#$$))%)*;%<%<%B2%F")**b00S8m8mZl8m8m8m5m5m01H W  / /0BX / V V V %%sqA  AA&C<< E8EEFF9 FF  F F  F FFG((G,/G,rc|diD]%\}}||jvs |j| ||j|<&|j|dd|_dSdS)aParse model configuration and merge saved prompts/defaults with user-provided values. User-provided prompts and default_prompt_name take precedence over saved config values. Saved prompts are only used for keys not already present in ``self.prompts``, or where the current value is ``None`` (i.e. a default placeholder, not yet filled by the user or config). Empty string ``""`` is treated as an intentional user-provided value and will not be overwritten. r6Nr7)rfrr6r7)rrr prompt_texts r[rzBaseModel._parse_model_configs)5(8(8B(G(G(M(M(O(O 8 8 $K$,..$,{2K2S,7 [)  # +'3'7'78Mt'T'TD $ $ $ , +r]c >||||||||||  S)NrU)r) rrBr<r8r:r9r;r=r>r?r2s r[rz!BaseModel._load_converted_moduless<)) %/-%-'*   r]ct|d||||}|dSt|d5}tj|}|ddcdddS#1swxYwYdS)at Retrieves the model_type from the config_sentence_transformers.json file. This is used to determine whether the model being loaded matches the current class (e.g., a SentenceTransformer model loaded with SentenceTransformer, or a SparseEncoder model loaded with SparseEncoder). When the model type doesn't match, we switch to a converted loading method to ensure compatibility. Defaults to "SentenceTransformer" if the config file is missing or has no "model_type" key, for backwards compatibility with older models. Args: model_name_or_path (str): The name or path of the pre-trained model. token (Optional[Union[bool, str]]): The token to use for the model. cache_folder (Optional[str]): The folder to cache the model. revision (Optional[str], optional): The revision of the model. Defaults to None. local_files_only (bool, optional): Whether to use only local files. Defaults to False. Returns: str: The model type, e.g. "SentenceTransformer", "SparseEncoder", or "CrossEncoder". r)rNSentenceTransformerr+r,r2)r&r6r8rrf) rrBr<r8r:r;rrrFs r[rzBaseModel._get_model_types:2@  /%- 2 2 2 . 2 9(( 86 J J J CcYs^^F::l,ABB C C C C C C C C C C C C C C C C C Cs*A""A&)A&rI nn.Modulec d|r|ddnd} t||||| |||S)a Load a module class from a class reference string. Args: class_ref: The class reference string (e.g., "sentence_transformers.sentence_transformer.modules.Pooling") model_name_or_path: The model name or path trust_remote_code: Whether to trust remote code revision: The model revision model_kwargs: Additional model kwargs token: Hub auth token, required for private repos when fetching custom modeling files. cache_folder: Optional override for the Hub cache directory. local_files_only: Restrict to local cache (no Hub network calls). Returns: The module class code_revisionN)rBr9r:rr<r8r;)rr$) rrIrBr9r:r=r<r8r;rs r[rz%BaseModel._load_module_class_from_ref@sU6DPY (($???UY " 1/'%-    r] evaluatorr output_pathdict[str, float] | floatcJ|tj|d|||S)a? Evaluate the model based on an evaluator Args: evaluator (BaseEvaluator): The evaluator used to evaluate the model. output_path (str, optional): The path where the evaluator can write the results. Defaults to None. Returns: The evaluation results. NTr')rdr4)rrrs r[evaluatezBaseModel.evaluategs1  " K d 3 3 3 3y{+++r]gradient_checkpointing_kwargsc|D]Q}||urKt|dr; ||-#t$r|YMwxYwRdS)z,Enable gradient checkpointing for the model.gradient_checkpointing_enableN)r4rrr)rrrZs r[rz'BaseModel.gradient_checkpointing_enablevsllnn ; ;FT!!gf6U&V&V!;889VWWWW ;;;88:::::;  ; ;sAA#"A# torch.devicec|jx}t|dr|jSt|jrCt|ddr-t|djdr|djjS t |jS#t$r`d d }| | } t |}|d jcYS#t$rtjd cYcYSwxYwwxYw)z Get torch.device from module, assuming that the whole module has one device. In case there are no PyTorch parameters, fall back to CPU. Nr5r auto_modelrZrrJlist[tuple[str, Tensor]]cLd|jD}|S)NcDg|]\}}tj|||fSrW)r3 is_tensorrs r[r\zDBaseModel.device..find_tensor_attributes..s0[[[TQXYHZHZ[1a&[[[r])__dict__r)rZtupless r[find_tensor_attributesz0BaseModel.device..find_tensor_attributess([[V_-B-B-D-D[[[ r])get_members_fnrTcpu)rZrrJr) transformers_modelrr5ryrrrr StopIteration_named_membersr3)rrrgen first_tuples r[r5zBaseModel.devices@ #'"9 9  F7SegoKpKp F%, , t}   -'$q'<"@"@ -WTRSWM_aiEjEj -7%, , +))**1 1 + + +    %%5K%LLC +"3ii "1~,,,,  + + +|E******* + +s09%B$D C"D "DD DD target_devices2dict[Literal['input', 'output', 'processes'], Any]c ~|tjr6dttjD}ndt r6dttjD}n tddgdz}tdd tt|| d| tjd }|}|}g}|D]Q}||jj||||fd }|||R|||d S) aT Starts a multi-process pool to infer with several independent processes. This method is recommended if you want to predict on multiple GPUs or CPUs. It is advised to start only one process per GPU. This method works together with predict and stop_multi_process_pool. Args: target_devices (List[str], optional): PyTorch target devices, e.g. ["cuda:0", "cuda:1", ...], ["npu:0", "npu:1", ...], or ["cpu", "cpu", "cpu", "cpu"]. If target_devices is None and CUDA/NPU is available, then all available CUDA/NPU devices will be used. If target_devices is None and CUDA/NPU is not available, then 4 CPU devices will be used. Returns: Dict[str, Any]: A dictionary with the target processes, an input queue, and an output queue. Ncg|]}d|S)zcuda:rWrXis r[r\z6BaseModel.start_multi_process_pool..s!X!X!X!+!++!X!X!Xr]cg|]}d|S)znpu:rWrs r[r\z6BaseModel.start_multi_process_pool..s!V!V!V***!V!V!Vr]z1CUDA/NPU is not available. Starting 4 CPU workersrz(Starting multi-process pool on devices: z, spawnT)targetrdaemon)routput processes)r3cuda is_availablerange device_countrnpurgrhr7mapr0r share_memorymp get_contextrProcessr_multi_process_workerstartrC)rrctx input_queue output_queuer device_idps r[start_multi_process_poolz"BaseModel.start_multi_process_pools&  !z&&(( -!X!XuUZ=T=T=V=V7W7W!X!X!X')) -!V!VeEIrGr?rGr@rHrArIrJrK)rJrK)rr,rr,rJr,)rJrI)rJr)rrrJrE)rJr)rJr)rJr)rJrE)rrrJr)rJr)rrrJr)rrrr,rJr)rrrJr)rr rJrE)NTNT) rnr0r r,r!rEr"r#r$rErJrK)rJrN)rVr0rJr0)Nr\)rnr0r r,r"r#rJrK) NNNTrhNFFN)rir0rjr,r<r,rkrlr$rErmr0rnr,r(rErorEr"r#rJr0) NNTNNFFNNF)rir0r<r,rkrlr$rErmr,rnr,r(rErorEr"r#r:r,rsrErJr0)NFFNNN)rBr0r<rFr8r,r:r,r9rEr;rEr=rGr>rGr?rGrJr)rrNrJrK)NFFNNNN)rBr0r<rFr8r,r:r,r9rEr;rEr=rGr>rGr?rGr2r,rJr)NF) rBr0r<rFr8r,r:r,r;rErJr0)NNF)rIr0rBr0r9rEr:r,r=rGr<rFr8r,r;rErJr)rrrr,rJr)rrGrJrK)rJr)rr#rJr)rrrJrK) rr0rr+rrr rrJrK)rJr )rJr)rJr)rr)rJrK)r5rrJrK)rJr)rir0rJr0)Ar|r; __qualname____doc__rr`r-__annotations__r.r1r~rrrpropertyrrrrrrr staticmethodrrrrrrrr:r5rUr[rDr'rrrqrvrrrrrrrrrr5rrrrr setterrrrrFrrr"r%r~ __classcell__)rs@r[r+r+2s[".37$7777/10000,L$LLLLOOO*.{2IM!)-*.#'"'#!&#'.226/3+/8?#{2{2{2{2{2{2{2{2z,6888X8    D$$$$< # # # #8888<<<<$\ ///\/b$ 0 0 0 0 0 0$"88888t77776"&"&+/#' NFNFNFNFNF`     "&"&+/#'      6\h'#'#'#'#'#R $( ##'.'+#(+/> > > >  > F!##'%)'+#(+/#t%t%t%t%t%v $"'!&.226/30s0s0s0s0sd $"'!&.226/3    ^ D $"'!&.226/3F&F&F&F&F&P U U U U( $"'!&.226/3!%     < $!& ,C,C,C,C,Cj$(#'!&% % % % % N , , , , ,;;;;;+++X+8260V0V0V0V0Vd\(VVV V V V\ V!!!X!     !!!X! 888X8'''' X. 3 3 3X 3 ]&&&]&X  XX X r]r+)N __future__rrjrr8rdr?r=rreabcrr collectionsrmultiprocessingrpathlibrtypingr r r numpyrr3torch.multiprocessingrrQhuggingface_hubr r packagingrrrrrr!transformers.dynamic_module_utilsrtransformers.utilsrtransformers_loggingrPr%sentence_transformers.base.evaluationr#sentence_transformers.base.modalityrr)sentence_transformers.base.modality_typesrrr%sentence_transformers.base.model_cardrr"sentence_transformers.base.modulesrr r!%sentence_transformers.base.peft_mixinr"sentence_transformers.utilr#r$r%r&r'sentence_transformers.util.miscr(r) get_loggerr|rg Sequentialr+rWr]r[rFs"""""" ##############!!!!!!.......... """"""++++++++WWWWWWWWWWGGGGGG>>>>>>------??????ffffffffVVVVVVVVVVXXXXXXXXJJJJJJJJJJBBBBBBHGGGGG.------ (  ( 2 2ZZZZZ /ZZZZZr]