NgX$ddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZddlmZmZddlmZddlmZddlmZddlmZmZmZmZddlZddl Z ddl!mZ"ddl#Z#dd l$m%Z%dd lm&Z&dd l m'Z'm(Z(m)Z)dd l*m+Z+dd l#m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2ddl3m4Z4ddl5m6Z6m7Z7ddl8m9Z9ddl:m;Z;ddlZ>m?Z?ddl@mAZAddlBmCZCddlDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLejMeNZOGdde)jPe;eAZQdS)) annotationsN) OrderedDict)IterableIterator)contextmanager)Queue)Path)AnyCallableLiteraloverload)HfApi)ndarray)Tensordevicenn)trange)is_torch_npu_available)get_class_from_dynamic_moduleget_relative_import_files) SentenceTransformerModelCardDatagenerate_model_card)SimilarityFunction)__MODEL_HUB_ORGANIZATION__ __version__)SentenceEvaluator)FitMixin) NormalizePooling Transformer)PeftAdapterMixin)quantize_embeddings)batch_to_deviceget_device_nameimport_from_stringis_sentence_transformer_model load_dir_pathload_file_pathsave_to_hub_args_decoratortruncate_embeddingsc|eZdZdZ ddfd# Zdd$Ze ddd7Ze ddd;Ze ddd<Ze ddd?Z dddEZdfdH Ze ddJZ e j ddMZ eddPZ eddRZ e ddTZ eddUZ eddVZ e ddWZ ddd[Zedd]Z ddd_ZeddeZddgZddhZddkZddmZddnZeddpZddrZddsZ dddzZ ddd{Z ddd}Ze dddZ dddZ!ddZ"dddZ# dddZ$ddZ% dddZ&eddZ'e ddZ(e ddZ)e)j ddZ)e ddZ*e*j ddZ*e ddZ+e+j dddZ+e ddZ,e ddZ-dddZ.xZ/S)SentenceTransformerar Loads or creates a SentenceTransformer model that can be used to map sentences / text to embeddings. Args: model_name_or_path (str, optional): If it is a filepath on disc, it loads the model from that path. If it is not a path, it first tries to download a pre-trained SentenceTransformer model. If that fails, tries to construct a model from the Hugging Face Hub with that name. modules (Iterable[nn.Module], optional): A list of torch Modules that should be called sequentially, can be used to create custom SentenceTransformer models from scratch. device (str, optional): Device (like "cuda", "cpu", "mps", "npu") that should be used for computation. If None, checks if a GPU can be used. 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 to encode. For example: `{"query": "query: ", "passage": "passage: "}` or `{"clustering": "Identify the main category based on the titles in "}`. default_prompt_name (str, optional): The name of the prompt that should be used by default. If not set, no prompt will be applied. similarity_fn_name (str or SimilarityFunction, optional): The name of the similarity function to use. Valid options are "cosine", "dot", "euclidean", and "manhattan". If not set, it is automatically set to "cosine" if `similarity` or `similarity_pairwise` are called while `model.similarity_fn_name` is still `None`. cache_folder (str, optional): Path to store models. Can also be set by the SENTENCE_TRANSFORMERS_HOME environment variable. trust_remote_code (bool, optional): Whether or not to allow for custom models defined on the Hub in their own modeling files. This option should only be 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. 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. local_files_only (bool, optional): Whether or not to only look at local files (i.e., do not try to download the model). token (bool or str, optional): Hugging Face authentication token to download private models. use_auth_token (bool or str, optional): Deprecated argument. Please use `token` instead. truncate_dim (int, optional): The dimension to truncate sentence embeddings to. `None` does no truncation. Truncation is only applicable during inference when :meth:`SentenceTransformer.encode` is called. model_kwargs (Dict[str, Any], optional): Additional model configuration parameters to be passed to the Hugging Face Transformers model. Particularly useful options are: - ``torch_dtype``: Override the default `torch.dtype` and load the model under a specific `dtype`. The different options are: 1. ``torch.float16``, ``torch.bfloat16`` or ``torch.float``: load in a specified ``dtype``, ignoring the model's ``config.torch_dtype`` if one exists. If not specified - the model will get loaded in ``torch.float`` (fp32). 2. ``"auto"`` - A ``torch_dtype`` entry in the ``config.json`` file of the model will be attempted to be used. If this entry isn't found then next check the ``dtype`` of the first weight in the checkpoint that's of a floating point type and use that as ``dtype``. This will load the model using the ``dtype`` it was saved in at the end of the training. It can't be used as an indicator of how the model was trained. Since it could be trained in one of half precision dtypes, but saved in fp32. - ``attn_implementation``: The attention implementation to use in the model (if relevant). Can be any of `"eager"` (manual implementation of the attention), `"sdpa"` (using `F.scaled_dot_product_attention `_), or `"flash_attention_2"` (using `Dao-AILab/flash-attention `_). By default, if available, SDPA will be used for torch>=2.1.1. The default is otherwise the manual `"eager"` implementation. - ``provider``: If backend is "onnx", this is the provider to use for inference, for example "CPUExecutionProvider", "CUDAExecutionProvider", etc. See https://onnxruntime.ai/docs/execution-providers/ for all ONNX execution providers. - ``file_name``: If backend is "onnx" or "openvino", this is the file name to load, useful for loading optimized or quantized ONNX or OpenVINO models. - ``export``: If backend is "onnx" or "openvino", then this is a boolean flag specifying whether this model should be exported to the backend. If not specified, the model will be exported only if the model repository or directory does not already contain an exported model. See the `PreTrainedModel.from_pretrained `_ documentation for more details. tokenizer_kwargs (Dict[str, Any], optional): Additional tokenizer configuration parameters to be passed to the Hugging Face Transformers tokenizer. See the `AutoTokenizer.from_pretrained `_ documentation for more details. config_kwargs (Dict[str, Any], optional): Additional model configuration parameters to be passed to the Hugging Face Transformers config. See the `AutoConfig.from_pretrained `_ documentation for more details. model_card_data (:class:`~sentence_transformers.model_card.SentenceTransformerModelCardData`, optional): A model card data object that contains information about the model. This is used to generate a model card when saving the model. If not set, a default model card data object is created. backend (str): The backend to use for inference. Can be one of "torch" (default), "onnx", or "openvino". See https://sbert.net/docs/sentence_transformer/usage/efficiency.html for benchmarking information on the different backends. Example: :: from sentence_transformers import SentenceTransformer # Load a pre-trained SentenceTransformer model model = SentenceTransformer('all-mpnet-base-v2') # Encode some texts sentences = [ "The weather is lovely today.", "It's so sunny outside!", "He drove to the stadium.", ] embeddings = model.encode(sentences) print(embeddings.shape) # (3, 768) # Get the similarity scores between all sentences similarities = model.similarity(embeddings, embeddings) print(similarities) # tensor([[1.0000, 0.6817, 0.0492], # [0.6817, 1.0000, 0.0421], # [0.0492, 0.0421, 1.0000]]) NFtorchmodel_name_or_path str | NonemodulesIterable[nn.Module] | Nonerpromptsdict[str, str] | Nonedefault_prompt_namesimilarity_fn_namestr | SimilarityFunction | None cache_foldertrust_remote_codeboolrevisionlocal_files_onlytokenbool | str | Noneuse_auth_token truncate_dim int | None model_kwargsdict[str, Any] | Nonetokenizer_kwargs config_kwargsmodel_card_data'SentenceTransformerModelCardData | Nonebackend$Literal['torch', 'onnx', 'openvino']returnNonec ||pi|_||_||_||_| |_|p t |_d|_i|_d|_ i|_ ||_ | -tj dt| td| } |t!jd}|+t%}t&d||dkr/t*jdddlm}|||d krt&d |gd }t j|sWd |vs|d dkrtd|dd |vr#||vr t<d z|z}t?|| || | r'| || || || ||| \}|_n|!|| || || ||| }|;tE|tFs&tGdtI|D}tK&| tO|(j)}|*|n#tV$rYnwxYw|*|d|_,|jM|j|jvr?td|jdt[|j.d|jrUt&t_|jdt[|j.|jr#t&0d|jd|dvr|1dnh|rfd |vrbd|2d dvr3tgd|Drt&0d|j4|dS) Nz^The `use_auth_token` argument is deprecated and will be removed in v4 of SentenceTransformers.zV`token` and `use_auth_token` are both specified. Please set only the argument `token`.SENTENCE_TRANSFORMERS_HOMEzUse pytorch device_name: hpuoptimumr)adapt_transformers_to_gaudiz%Load pretrained SentenceTransformer: )Dzalbert-base-v1zalbert-base-v2zalbert-large-v1zalbert-large-v2zalbert-xlarge-v1zalbert-xlarge-v2zalbert-xxlarge-v1zalbert-xxlarge-v2zbert-base-cased-finetuned-mrpczbert-base-casedzbert-base-chinesezbert-base-german-casedzbert-base-german-dbmdz-casedzbert-base-german-dbmdz-uncasedzbert-base-multilingual-casedzbert-base-multilingual-uncasedzbert-base-uncasedz3bert-large-cased-whole-word-masking-finetuned-squadz#bert-large-cased-whole-word-maskingzbert-large-casedz5bert-large-uncased-whole-word-masking-finetuned-squadz%bert-large-uncased-whole-word-maskingzbert-large-uncasedzcamembert-basectrlz%distilbert-base-cased-distilled-squadzdistilbert-base-casedzdistilbert-base-german-casedz"distilbert-base-multilingual-casedz'distilbert-base-uncased-distilled-squadz/distilbert-base-uncased-finetuned-sst-2-englishzdistilbert-base-uncased distilgpt2zdistilroberta-basez gpt2-largez gpt2-mediumzgpt2-xlgpt2z openai-gptzroberta-base-openai-detectorz roberta-basezroberta-large-mnlizroberta-large-openai-detectorz roberta-largezt5-11bzt5-3bzt5-basezt5-largezt5-smallztransfo-xl-wt103zxlm-clm-ende-1024zxlm-clm-enfr-1024zxlm-mlm-100-1280zxlm-mlm-17-1280zxlm-mlm-en-2048zxlm-mlm-ende-1024zxlm-mlm-enfr-1024zxlm-mlm-enro-1024zxlm-mlm-tlm-xnli15-1024zxlm-mlm-xnli15-1024zxlm-roberta-basez)xlm-roberta-large-finetuned-conll02-dutchz+xlm-roberta-large-finetuned-conll02-spanishz+xlm-roberta-large-finetuned-conll03-englishz*xlm-roberta-large-finetuned-conll03-germanzxlm-roberta-largezxlnet-base-casedzxlnet-large-cased\/rzPath z not found)r8r;r<)r=r8r;r9r<rBrDrEc6g|]\}}t||fS)str).0idxmodules e/var/www/html/ai-engine/env/lib/python3.11/site-packages/sentence_transformers/SentenceTransformer.py z0SentenceTransformer.__init__..Ms'"\"\"\+#vCHHf#5"\"\"\FzDefault prompt name ';' not found in the configured prompts dictionary with keys .z$ prompts are loaded, with the keys: zDefault prompt name is set to 'z'. This prompt will be applied to all `encode()` calls, except if `encode()` is called with `prompt` or `prompt_name` parameters.)zhkunlp/instructor-basezhkunlp/instructor-largezhkunlp/instructor-xl)include_prompt instructorcFg|]}t|t|jSrX isinstancer rb)rZr\s r]r^z0SentenceTransformer.__init__..xs+\\\f 6SZ@[@[\F)\\\r_zInstructor models require `include_prompt=False` in the pooling configuration. Either update the model configuration or call `model.set_pooling_include_prompt(False)` after loading the model.)5r3r5r6r9r@rrF module_kwargs_model_card_vars_model_card_text _model_configrHwarningswarn FutureWarning ValueErrorosgetenvr%loggerinfo importlibutil find_spec*optimum.habana.transformers.modeling_utilsrPpathexistscountlowerrr'_load_sbert_model_load_auto_modelrfr enumeratesuper__init__next parametersdtypeto StopIterationis_hpu_graph_enabledlistkeyslenwarningset_pooling_include_promptsplitanyregister_model)selfr/r1rr3r5r6r8r9r;r<r=r?r@rBrDrErFrHrPbasic_transformer_modelsr __class__s r]rzSentenceTransformer.__init__s,}" #6 "4!2(.T2R2T2T! " $  % Mp     l#E  9%ABBL >$&&F KK>"455 _---1C1I1I#1N1NQR1R1R$%K-?%K%K%KLLL0005G5M5M5O5OWo5o5o)Cc)IL^)^&,")!!1  /3.D.D&!-%&7%5!-%5"//E / /+++//&!-%&7%5!-%5"/0    z';'G'G !"\"\SZI[I["\"\"\]]G !!!  **++1E GGENNNN    D  $)!  # /D4LTXT`4`4`G(@GG(,T\->->-@-@(A(AGGG  < o KK3t|,,mmRVW[WcWhWhWjWjRkRkmm n n n  #  NNG$2JGGG    !n n n  + +5 + A A A A  ))) 2 8 8 = =a @ F F H HHH\\\\\]] G ++D11111s;J J&%J&c|jS)zReturn the backend used for inference, which can be one of "torch", "onnx", or "openvino". Returns: str: The backend used for inference. )rHrs r] get_backendzSentenceTransformer.get_backends |r_. sentencesrY prompt_nameprompt batch_sizeintshow_progress_bar bool | None output_value8Literal['sentence_embedding', 'token_embeddings'] | None precision8Literal['float32', 'int8', 'uint8', 'binary', 'ubinary']convert_to_numpyLiteral[False]convert_to_tensornormalize_embeddingsrc  dSNrX rrrrrrrrrrrrkwargss r]encodezSentenceTransformer.encode r_str | list[str] Literal[True] np.ndarrayc  dSrrXrs r]rzSentenceTransformer.encodes Sr_c  dSrrXrs r]rzSentenceTransformer.encoderr_list[str] | np.ndarray list[Tensor]c  dSrrXrs r]rzSentenceTransformer.encodes sr_ sentence_embeddingfloat32T"list[Tensor] | np.ndarray | Tensorc  jjdkr0js)ddlm} | jdd_|1t tj tj fv}| rd}|dkrd} d}d}ttstdsgd}|W j|n#t"$r;t%d |d t'jd wxYwj jjdn|td i}Afd Dg}d|vr|djddz |d<| j} | gt7jfdD}fd|D}t;dt=|d| D]^}||||z}|}jjdkr d|vr|dj}dt?j t?j!|dz|dz }t j"|dt j#|d|ftj$fd|d<t j"|dt j%|d|ftj$fd|d<d|vrFt j"|dt j%|d|ftj$fd|d<tM|| }|'|t j(5j)|fi| jjdkrtUj+tYdj-d<|dkrg}t]|dD]\}}t=|dz }|dkrG||/dkr)|dz}|dkr||/dk)|0|d|dzn|Lg}tct=dD]&fdD}|0|'n[|}|2}| r'tj3j45|dd}|r|6}7|dddn #1swxYwY`fdt7j|D|r|dkrtq|| rgt=rDtt6j9rt j:nt j;nt j<n|rutt6j9sZr:dj=tj>krt7j?d DnEt7j?d!Dn&tt6j9r d"D|rdS)#a2 Computes sentence embeddings. Args: sentences (Union[str, List[str]]): The sentences to embed. prompt_name (Optional[str], optional): The name of the prompt to use for encoding. Must be a key in the `prompts` dictionary, which is either set in the constructor or loaded from the model configuration. For example if ``prompt_name`` is "query" and the ``prompts`` is {"query": "query: ", ...}, then the sentence "What is the capital of France?" will be encoded as "query: What is the capital of France?" because the sentence is appended to the prompt. If ``prompt`` is also set, this argument is ignored. Defaults to None. prompt (Optional[str], optional): The prompt to use for encoding. For example, if the prompt is "query: ", then the sentence "What is the capital of France?" will be encoded as "query: What is the capital of France?" because the sentence is appended to the prompt. If ``prompt`` is set, ``prompt_name`` is ignored. Defaults to None. batch_size (int, optional): The batch size used for the computation. Defaults to 32. show_progress_bar (bool, optional): Whether to output a progress bar when encode sentences. Defaults to None. output_value (Optional[Literal["sentence_embedding", "token_embeddings"]], optional): The type of embeddings to return: "sentence_embedding" to get sentence embeddings, "token_embeddings" to get wordpiece token embeddings, and `None`, to get all output values. Defaults to "sentence_embedding". precision (Literal["float32", "int8", "uint8", "binary", "ubinary"], optional): The precision to use for the embeddings. Can be "float32", "int8", "uint8", "binary", or "ubinary". All non-float32 precisions are quantized embeddings. Quantized embeddings are smaller in size and faster to compute, but may have a lower accuracy. They are useful for reducing the size of the embeddings of a corpus for semantic search, among other tasks. Defaults to "float32". convert_to_numpy (bool, optional): Whether the output should be a list of numpy vectors. If False, it is a list of PyTorch tensors. Defaults to True. convert_to_tensor (bool, optional): Whether the output should be one large tensor. Overwrites `convert_to_numpy`. Defaults to False. device (str, optional): Which :class:`torch.device` to use for the computation. Defaults to None. normalize_embeddings (bool, optional): Whether to normalize returned vectors to have length 1. In that case, the faster dot-product (util.dot_score) instead of cosine similarity can be used. Defaults to False. Returns: Union[List[Tensor], ndarray, Tensor]: By default, a 2d numpy array with shape [num_inputs, output_dimension] is returned. If only one string input is provided, then the output is a 1d array with shape [output_dimension]. If ``convert_to_tensor``, a torch Tensor is returned instead. If ``self.truncate_dim <= output_dimension`` then output_dimension is ``self.truncate_dim``. Example: :: from sentence_transformers import SentenceTransformer # Load a pre-trained SentenceTransformer model model = SentenceTransformer('all-mpnet-base-v2') # Encode some texts sentences = [ "The weather is lovely today.", "It's so sunny outside!", "He drove to the stadium.", ] embeddings = model.encode(sentences) print(embeddings.shape) # (3, 768) rNrNT)disable_tensor_cacheFr__len__z Prompt name 'r`razzEncode with either a `prompt`, a `prompt_name`, or neither, but not both. Ignoring the `prompt_name` in favor of `prompt`.cg|]}|zSrXrX)rZsentencers r]r^z.SentenceTransformer.encode..<sEEEx(*EEEr_ input_idsr prompt_lengthc<g|]}| SrX) _text_length)rZsenrs r]r^z.SentenceTransformer.encode..Js*'U'U'UC):):3)?)?(?'U'U'Ur_c g|] }| SrXrX)rZr[rs r]r^z.SentenceTransformer.encode..KsHHHsIcNHHHr_Batchesdescdisable)rattention_masktoken_type_idstoken_embeddingsc.i|]}||SrXrX)rZname out_featuressent_idxs r] z.SentenceTransformer.encode..s%[[[dt\$%7%A[[[r_)pdimc g|] }| SrXrX)rZr[all_embeddingss r]r^z.SentenceTransformer.encode..sWWW#.-WWWr_r)rcZg|](}|)SrX)floatnumpyrZembs r]r^z.SentenceTransformer.encode..s,0_0_0_1B1B1D1D0_0_0_r_c6g|]}|SrX)rrs r]r^z.SentenceTransformer.encode..s 0W0W0W0W0W0Wr_c6g|]}tj|SrX)r. from_numpy)rZ embeddings r]r^z.SentenceTransformer.encode..s#ZZZie.y99ZZZr_)@rtyperhabana_frameworks.torchr.rNwrap_in_hpu_graphevalrqgetEffectiveLevelloggingINFODEBUGrfrYhasattrr3KeyErrorrnrrr5getrtokenizeshapernpargsortrrmathceillog2catonesint8zerosr$updateno_gradforwardcopydeepcopyr+r@zipitemappendrangedetachr functional normalizecpuextendr#rrstackrrbfloat16asarray) rrrrrrrrrrrrrhtinput_was_stringextra_featurestokenized_promptlength_sorted_idxsentences_sorted start_indexsentences_batchfeaturescurr_tokenize_lenadditional_pad_len embeddings token_emb attention last_mask_idrowrrrs `` ` @@@r]rzSentenceTransformer.encodes?H ; u $ $T-F $ 0 0 0 0 0 0 F $ $T $ E E E(,D %  $ & 8 8 : :w|W]>[ [   %$  / / / % $   i % % $W y. .  $# I#  >&!\+6FF$O OOptuyvBvGvGvIvIqJqJOOO)5))$*BDII&G   EEEE9EEEI $}}fX66 ...2B;2O2UVX2Y\]2]/ >[F J'U'U'U'U9'U'U'UVVHHHH6GHHH!!S^^Zi]nYnoooA 2A 2K.{[:=U/UVO}}_55H{5(((**(0(=(C%)*di BSTUBV8W8W.X.X)X[lmn[o)o&,1I$[1!J(9!(<>P'QY^Ycddd --H[)27$%56!K):1)=?Q(RZ_Zdeee 22H-.(8335:Y ()9 : % ->q-ACU,V^c^h i i i 66!12'x88H OON + + + 2 2+t|H???? ;#u,,#'=#>#>L5H !568I66 12 #555!#J03L4NP\]mPn0o0oKK, 9'*9~~'9 *Q..9\3J3O3O3Q3QUV3V3V(A-L+Q..9\3J3O3O3Q3QUV3V3V#)))A q8H4H*IJJJJ K ")!#J$)#l;O.P*Q*Q$R$R//[[[[[l[[["))#..../".l!;J!+!2!2!4!4J+[%*X%8%B%B:QRXY%B%Z%Z (6%/^^%5%5 %%j111A 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2DXWWWDU9V9VWWW  Vi//09UUUN  [>"" 0nbj99A%*%5n%E%ENN%*[%@%@NN!&  [nbj99 Y!YnQ&7&=&O&O%'Z0_0_P^0_0_0_%`%`NN%'Z0W0W0W0W0W%X%XN  3 3 [ZZ>ZZZN  /+A.Ns CAD *F9U//U3 6U3 inputdict[str, Tensor]c |j!t|S|D]I\}}|j|gfd|D}||fi|}J|S)Nc$i|] \}}|v || SrXrX)rZkeyvaluemodule_kwarg_keyss r]rz/SentenceTransformer.forward..s*eeeJCCSdLdLdS%LdLdLdr_)rgr~rnamed_childrenritems)rrr module_namer\rgrrs @r]rzSentenceTransformer.forwards   %77??5)) )#'#6#6#8#8 3 3 K $ 2 6 6{B G G eeee&,,..eeeMF522M22EE r_2Literal['cosine', 'dot', 'euclidean', 'manhattan']c@|jtj|_|jS)aReturn the name of the similarity function used by :meth:`SentenceTransformer.similarity` and :meth:`SentenceTransformer.similarity_pairwise`. Returns: Optional[str]: The name of the similarity function. Can be None if not set, in which case it will default to "cosine" when first called. Example: >>> model = SentenceTransformer("multi-qa-mpnet-base-dot-v1") >>> model.similarity_fn_name 'dot' )_similarity_fn_namerCOSINEr6rs r]r6z&SentenceTransformer.similarity_fn_names!  # +&8&?D #''r_rGLiteral['cosine', 'dot', 'euclidean', 'manhattan'] | SimilarityFunctionct|tr|j}||_|4tj||_tj||_dSdSr)rfrrrto_similarity_fn _similarityto_similarity_pairwise_fn_similarity_pairwiserrs r]r6z&SentenceTransformer.similarity_fn_namesa e/ 0 0 KE#(  1B5IID (:(TUZ([([D % % %  r_ embeddings1 embeddings2cdSrrXrr'r(s r] similarityzSentenceTransformer.similaritysNQcr_rcdSrrXr*s r]r+zSentenceTransformer.similaritysPSPSr_6Callable[[Tensor | ndarray, Tensor | ndarray], Tensor]c@|jtj|_|jS)a Compute the similarity between two collections of embeddings. The output will be a matrix with the similarity scores between all embeddings from the first parameter and all embeddings from the second parameter. This differs from `similarity_pairwise` which computes the similarity between each pair of embeddings. Args: embeddings1 (Union[Tensor, ndarray]): [num_embeddings_1, embedding_dim] or [embedding_dim]-shaped numpy array or torch tensor. embeddings2 (Union[Tensor, ndarray]): [num_embeddings_2, embedding_dim] or [embedding_dim]-shaped numpy array or torch tensor. Returns: Tensor: A [num_embeddings_1, num_embeddings_2]-shaped torch tensor with similarity scores. Example: :: >>> model = SentenceTransformer("all-mpnet-base-v2") >>> sentences = [ ... "The weather is so nice!", ... "It's so sunny outside.", ... "He's driving to the movie theater.", ... "She's going to the cinema.", ... ] >>> embeddings = model.encode(sentences, normalize_embeddings=True) >>> model.similarity(embeddings, embeddings) tensor([[1.0000, 0.7235, 0.0290, 0.1309], [0.7235, 1.0000, 0.0613, 0.1129], [0.0290, 0.0613, 1.0000, 0.5027], [0.1309, 0.1129, 0.5027, 1.0000]]) >>> model.similarity_fn_name "cosine" >>> model.similarity_fn_name = "euclidean" >>> model.similarity(embeddings, embeddings) tensor([[-0.0000, -0.7437, -1.3935, -1.3184], [-0.7437, -0.0000, -1.3702, -1.3320], [-1.3935, -1.3702, -0.0000, -0.9973], [-1.3184, -1.3320, -0.9973, -0.0000]]) )r6rrr#rs r]r+zSentenceTransformer.similaritys"N  " *&8&?D #r_cdSrrXr*s r]similarity_pairwisez'SentenceTransformer.similarity_pairwisesWZWZr_cdSrrXr*s r]r0z'SentenceTransformer.similarity_pairwisesY\Y\r_c@|jtj|_|jS)a Compute the similarity between two collections of embeddings. The output will be a vector with the similarity scores between each pair of embeddings. Args: embeddings1 (Union[Tensor, ndarray]): [num_embeddings, embedding_dim] or [embedding_dim]-shaped numpy array or torch tensor. embeddings2 (Union[Tensor, ndarray]): [num_embeddings, embedding_dim] or [embedding_dim]-shaped numpy array or torch tensor. Returns: Tensor: A [num_embeddings]-shaped torch tensor with pairwise similarity scores. Example: :: >>> model = SentenceTransformer("all-mpnet-base-v2") >>> sentences = [ ... "The weather is so nice!", ... "It's so sunny outside.", ... "He's driving to the movie theater.", ... "She's going to the cinema.", ... ] >>> embeddings = model.encode(sentences, normalize_embeddings=True) >>> model.similarity_pairwise(embeddings[::2], embeddings[1::2]) tensor([0.7235, 0.5027]) >>> model.similarity_fn_name "cosine" >>> model.similarity_fn_name = "euclidean" >>> model.similarity_pairwise(embeddings[::2], embeddings[1::2]) tensor([-0.7437, -0.9973]) )r6rrr%rs r]r0z'SentenceTransformer.similarity_pairwise s"@  " *&8&?D #((r_target_devices list[str]2dict[Literal['input', 'output', 'processes'], Any]c |tjr6dttjD}ndt r6dttjD}n tddgdz}td d tt|| d|tjd }|}|}g}|D]Q}|t&j||||fd }|||R|||d S) a Starts a multi-process pool to process the encoding with several independent processes via :meth:`SentenceTransformer.encode_multi_process `. This method is recommended if you want to encode on multiple GPUs or CPUs. It is advised to start only one process per GPU. This method works together with encode_multi_process 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:rXrZis r]r^z@SentenceTransformer.start_multi_process_pool..Cs!X!X!X!+!++!X!X!Xr_cg|]}d|S)znpu:rXr8s r]r^z@SentenceTransformer.start_multi_process_pool..Es!V!V!V***!V!V!Vr_z1CUDA/NPU is not available. Starting 4 CPU workersrz'Start multi-process pool on devices: {}z, spawnT)targetargsdaemon)routput processes)r.cuda is_availabler device_countrnpurqrrformatjoinmaprYr share_memorymp get_contextrProcessr-_encode_multi_process_workerstartr)rr3ctx input_queue output_queuerA device_idrs r]start_multi_process_poolz,SentenceTransformer.start_multi_process_pool-s(  !z&&(( -!X!XuUZ=T=T=V=V7W7W!X!X!X')) -!V!VeEI`. The sentences are chunked into smaller packages and sent to individual processes, which encode them on different GPUs or CPUs. This method is only suitable for encoding large sets of sentences. Args: sentences (List[str]): List of sentences to encode. pool (Dict[Literal["input", "output", "processes"], Any]): A pool of workers started with :meth:`SentenceTransformer.start_multi_process_pool `. prompt_name (Optional[str], optional): The name of the prompt to use for encoding. Must be a key in the `prompts` dictionary, which is either set in the constructor or loaded from the model configuration. For example if ``prompt_name`` is "query" and the ``prompts`` is {"query": "query: ", ...}, then the sentence "What is the capital of France?" will be encoded as "query: What is the capital of France?" because the sentence is appended to the prompt. If ``prompt`` is also set, this argument is ignored. Defaults to None. prompt (Optional[str], optional): The prompt to use for encoding. For example, if the prompt is "query: ", then the sentence "What is the capital of France?" will be encoded as "query: What is the capital of France?" because the sentence is appended to the prompt. If ``prompt`` is set, ``prompt_name`` is ignored. Defaults to None. batch_size (int): Encode sentences with batch size. (default: 32) chunk_size (int): Sentences are chunked and sent to the individual processes. If None, it determines a sensible size. Defaults to None. show_progress_bar (bool, optional): Whether to output a progress bar when encode sentences. Defaults to None. precision (Literal["float32", "int8", "uint8", "binary", "ubinary"]): The precision to use for the embeddings. Can be "float32", "int8", "uint8", "binary", or "ubinary". All non-float32 precisions are quantized embeddings. Quantized embeddings are smaller in size and faster to compute, but may have lower accuracy. They are useful for reducing the size of the embeddings of a corpus for semantic search, among other tasks. Defaults to "float32". normalize_embeddings (bool): Whether to normalize returned vectors to have length 1. In that case, the faster dot-product (util.dot_score) instead of cosine similarity can be used. Defaults to False. Returns: np.ndarray: A 2D numpy array with shape [num_inputs, output_dimension]. Example: :: from sentence_transformers import SentenceTransformer def main(): model = SentenceTransformer("all-mpnet-base-v2") sentences = ["The weather is so nice!", "It's so sunny outside.", "He's driving to the movie theater.", "She's going to the cinema."] * 1000 pool = model.start_multi_process_pool() embeddings = model.encode_multi_process(sentences, pool) model.stop_multi_process_pool(pool) print(embeddings.shape) # => (4000, 768) if __name__ == "__main__": main() NrA izChunk data into z packages of size rrrr@c8g|]}SrX)r)rZ_rQs r]r^z.s% m m mA\     m m mr_Chunksrc|dS)NrrX)xs r]z:SentenceTransformer.encode_multi_process..s !A$r_)rcg|] }|d S)rrX)rZresults r]r^z.s$J$J$J6VAY$J$J$Jr_)minrrrrqrrrrdebugrputsortedrr concatenate)rrrTrrrrYrrrrP last_chunk_idchunkr results_listr rQs @r]encode_multi_processz(SentenceTransformer.encode_multi_processssB  TYs9~~D[ [  n #i..:2M(N(Nnnblnnooo7m  !  H LL " " "5zzZ''"J{FIWkl"  u::>> OO]J{FT]_st u u u Q MH~  m m m m HZkVk)l)l)l m m m   ^$J$J\$J$J$JKK r_ target_devicemodelrPr results_queuec  |\}}}}}} } |||||d| d||  } ||| gn#tj$rYdSwxYwj)zU Internal working process to encode sentences in multi-process setup TF)rrrrrrrrN)rrrfqueueEmpty) rmrnrProchunk_idrrrrrrr s r]rMz0SentenceTransformer._encode_multi_process_workers  OO%%f*ifiQe#\\ +!(&+'%)))=*   !!8Z"89999;    % sAAA('A(rbcN|D]!}t|tr ||_dS"dS)av Sets the `include_prompt` attribute in the pooling layer in the model, if there is one. This is useful for INSTRUCTOR models, as the prompt should be excluded from the pooling strategy for these models. Args: include_prompt (bool): Whether to include the prompt in the pooling layer. Returns: None Nre)rrbr\s r]rz.SentenceTransformer.set_pooling_include_promptsC  F&'** (6%   r_c|t|dr|jSdS)z Returns the maximal sequence length that 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_lengthN)r _first_modulervrs r]get_max_seq_lengthz&SentenceTransformer.get_max_seq_lengths= 4%%'')9 : : 7%%''6 6tr_texts.list[str] | list[dict] | list[tuple[str, str]]cP||S)aW Tokenizes the texts. Args: texts (Union[List[str], List[Dict], List[Tuple[str, str]]]): A list of texts to be tokenized. Returns: Dict[str, Tensor]: A dictionary of tensors with the tokenized texts. Common keys are "input_ids", "attention_mask", and "token_type_ids". )rwr)rrys r]rzSentenceTransformer.tokenizes$!!##,,U333r_+dict[Literal['sentence_embedding'], Tensor]c:|j|Sr)rwget_sentence_features)rr s r]r~z)SentenceTransformer.get_sentence_featuress9t!!##98DDr_cd}t|jD].}t|dd}t |r |}n/|j!t |p tj|jS|S)a Returns the number of dimensions in the output of :meth:`SentenceTransformer.encode `. Returns: Optional[int]: The number of dimensions in the output of `encode`. If it's not known, it's `None`. N get_sentence_embedding_dimension) reversed_modulesvaluesgetattrcallabler@rdrinf)r output_dimmodsent_embedding_dim_methods r]rz4SentenceTransformer.get_sentence_embedding_dimensions DM002233  C(/5WY](^(^ %122 6688     (z+RVT->?? ?r_Iterator[None]c#VK|j} ||_dV||_dS#||_wxYw)aW In this context, :meth:`SentenceTransformer.encode ` outputs sentence embeddings truncated at dimension ``truncate_dim``. This may be useful when you are using the same model for different applications where different dimensions are needed. Args: truncate_dim (int, optional): The dimension to truncate sentence embeddings to. ``None`` does no truncation. Example: :: from sentence_transformers import SentenceTransformer model = SentenceTransformer("all-mpnet-base-v2") with model.truncate_sentence_embeddings(truncate_dim=16): embeddings_truncated = model.encode(["hello there", "hiya"]) assert embeddings_truncated.shape[-1] == 16 N)r@)rr@original_output_dims r]truncate_sentence_embeddingsz0SentenceTransformer.truncate_sentence_embeddings2sJ.#/ 4 ,D  EEE 3D    3D  3 3 3 3s  (torch.nn.ModulecZ|jtt|jS)z4Returns the first module of this sequential embedder)rriterrs r]rwz!SentenceTransformer._first_modulePs!}T$t}"5"56677r_cZ|jtt|jS)z3Returns the last module of this sequential embedder)rrrrs r] _last_modulez SentenceTransformer._last_moduleTs!}T(4="9"9::;;r_rw model_namecreate_model_cardtrain_datasetslist[str] | Nonesafe_serializationcR|dStj|dtd|g}tt jt jd|jd<ttj |dd5}|j }|j |d <|j |d <|j|d <tj||d dddn #1swxYwYt#|jD]$\} } |j| } | dkrt'| dr|dz} nEtj |t)| dzt+| jz} tj| d | | |n%#t0$r| | YnwxYwt+| j} | drt6j| j}t=| t=|jz }tAj ||tC|D];}t=| t=|jz }tAj ||<| "dddt+| j} n.| ds| dt+| j} |#| | tj $| | d&ttj |dd5}tj||d dddn #1swxYwY|r|%|||dSdS) Saves a model and its configuration files to a directory, so that it can be loaded with ``SentenceTransformer(path)`` again. Args: path (str): Path on disc where the model will be saved. model_name (str, optional): Optional model name. create_model_card (bool, optional): If True, create a README.md with basic information about this model. train_datasets (List[str], optional): Optional list with the names of the datasets used to train the model. safe_serialization (bool, optional): If True, save the model using safetensors. If False, save the model the traditional (but unsafe) PyTorch way. NTexist_okzSave model to )sentence_transformers transformerspytorchr!config_sentence_transformers.jsonwr3r5r6r)indentr save_in_rootrVr])rztransformers_modules.rarsentence_transformers.)r[rrwr modules.json)&romakedirsrqrrrrr.rjopenrwrGrr3r5r6jsondumpr}rrrYr__name__save TypeError __module__ startswithsysr1__file__r rshutilrrrbasename_create_model_card)rrwrrrrmodules_configfOutconfigr[rr\ model_path class_ref class_file dest_file needed_files r]rzSentenceTransformer.saveXs( < F D4(((( +T++,,,&1(4(- - =) "',,t%HII3 O O .SW',,..F $ F9 ,0,DF( )+/+BF' ( Ifd1 - - - -  . . . . . . . . . . . . . . .#4=11# w# wIC]4(FaxxGFN;;x!CZ 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 ))*BCC C(BB4<<+@BB  ! !#tRWEUEUV`EaEakt"u"u v v v v "',,t^44c : : 6d 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 Fs7AC**C.1C.F,,G GNNNc:||||||dS)rrrrrN)r)rrwrrrrs r]save_pretrainedz#SentenceTransformer.save_pretraineds8( !/)1      r_ deprecatedct|r;t|}|s|jjs ||j_|jrD|jj8|j}|jjr$|dd|jjd}nQ t|}n@#t$r3t dtj dYdSwxYwttj|ddd 5}||ddddS#1swxYwYdS) a  Create an automatic model and stores it in the specified path. If no training was done and the loaded model was a Sentence Transformer model already, then its model card is reused. 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. Defaults to "deprecated". Returns: None Nzp>p:p!$$'/&7#1'9 %!..# '#1'9%' /                $  %$ $$$sA;E&&E*-E*textlist[int] | list[list[int]]crt|tr;ttt |St |dsdSt|dkst|dtrt|Std|DS)z Help function to get the length for the input text. Text can be either a list of ints (which means a single text as input), or a tuple of list of ints (representing several text inputs to the model). rrrc,g|]}t|SrX)r)rZts r]r^z4SentenceTransformer._text_length..s---1A---r_) rfdictrrrrrrsum)rrs r]rz SentenceTransformer._text_lengths dD ! ! /tD//0011 1y)) /1 YY!^^z$q'377^t99 -----.. .r_ evaluatorr output_pathdict[str, float] | floatcJ|tj|d|||S)aC Evaluate the model based on an evaluator Args: evaluator (SentenceEvaluator): 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)ror)rrrs r]evaluatezSentenceTransformer.evaluates1  " K d 3 3 3 3y{+++r_list[nn.Module]c @td|d||||d} || ni| |}|| ni| |}| | ni| | } t||||| |j} t | d} |j||| | gS)ad Creates a simple Transformer + Mean Pooling model and returns the modules 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. tokenizer_kwargs (Optional[Dict[str, Any]], optional): Additional keyword arguments for the 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. z/No sentence-transformers model found with name z'. Creating a new one with mean pooling.r=r9r;r<N) cache_dir model_argstokenizer_args config_argsrHmeanr;)rqrr!rHr get_word_embedding_dimensionrFset_base_model) rr/r=r8r;r9r<rBrDrE shared_kwargstransformer_model pooling_models r]r|z$SentenceTransformer._load_auto_models:  y>P y y y   !2 0   )5(<}}Bc]BcVbBc ,<,D==Jo]Jo^nJo)6)> Df}DfXeDf ' "#+%L     1 N N P PRXYY  ++,>+RRR!=11r_r nn.Modulec|drt|S|r>|r|ddnd} t||||S#t$rYnwxYwt|S)Nr code_revision)r;r)rr&poprOSError)rrr/r9r;rBrs r]_load_module_class_from_refz/SentenceTransformer._load_module_class_from_refs    8 9 9 1%i00 0  GS]L,,_dCCCY]M 4&%"/      "),,,sA A"!A"dict[str, nn.Module]c  t|d||||} | -t| 5} tj| |_dddn #1swxYwYd|jvrod|jdvr`|jddt krDt d|jddt |j |j dd|_ |j s |j di|_ |j s |j d d|_ t|d ||||} | T t| d 5} | |_dddn #1swxYwYn#t $rYnwxYwt|d ||||} t| 5} tj| }dddn #1swxYwYt#}t#}|D]q}|d}||||||}|ddkri}dD]}t||||||}|t|5} tj| }d|vr%d|dvr|ddd|vr%d|dvr|ddd|vr%d|dvr|dddddn #1swxYwYn||||d}d|vri|d<d|vri|d<d|vri|d<|d||d||d||r|d||r|d|| r|d|  ||f||jd|}nc#t,$r||}YnBwxYw|t.krd}nt1||d||||}||}|||d<| dg||d<s|Vt3| }t5|jdkr/t3| jd}t5|dkr|}|j||||fS)af Loads a full SentenceTransformer 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. tokenizer_kwargs (Optional[Dict[str, Any]], optional): Additional keyword arguments for the tokenizer. Defaults to None. config_kwargs (Optional[Dict[str, Any]], optional): Additional keyword arguments for the config. Defaults to None. Returns: OrderedDict[str, nn.Module]: An ordered dictionary containing the modules of the model. r)r=r8r;r<NrrzYou try to use a model that was created with version {}, however, your version is {}. This might cause unexpected behavior or errors. In that case, try to update to the latest version. r6r3r5rrrrrrwrQ)zsentence_bert_config.jsonzsentence_roberta_config.jsonzsentence_distilbert_config.jsonzsentence_camembert_config.jsonzsentence_albert_config.jsonz sentence_xlm-roberta_config.jsonzsentence_xlnet_config.jsonrr9rrr)rrHrrr(r)r)rrloadrjrrqrrFrrr6r3r5readrirrr rrrHrrr(r rpartsrFr)rr/r=r8r;r9r<rBrDrE&config_sentence_transformers_json_pathfInmodel_card_pathmodules_json_pathrr1rg module_configr module_classr config_name config_path hub_kwargsr\ module_path path_partsrevision_path_parts r]r{z%SentenceTransformer._load_sbert_model sY<2@  /%- 2 2 2 . 2 =<== 4%)Ys^^" 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4!333+t/A-/PPP&}56MNQ\\\U\\*=9:QRT_'/*.*<*@*@AUW[*\*\'< E#155iDD + _+/+=+A+ABWY]+^+^()  %-      & /F;;;7s,/HHJJD)777777777777777    +  %-    # $ $ ,!Ys^^N , , , , , , , , , , , , , , ,--# +X SX SM%f-I;;-/@(LL V$**$K#1*##%1!))9 ###K#.!+..O#%)Ys^^F+v55:MQWXdQe:e:e &| 4 8 89L M M M/699>QU[\lUm>m>m &'7 8 < <=P Q Q Q,66;NRXYfRg;g;g &} 5 9 9:M N N NOOOOOOOOOOOOOOO/#): ((8   v--+-F<(#611/1F+, ..,.F=)|$++J777'(// ;;;}%,,Z888 ><(// ===#F+,334DEEE @=)00???C)\*<u ^b^juuntuuFF CCC)../ABBFFFC 9,,"&KK"/*%f-#%1!))9 ###K&**;77-3GM&) *3@3D3DXr3R3RM-/ 0 0  /00J:#$$))%)*;%<%<%B2%F")**b001H ++,>+RRR %%s~AAAF!/F F!FF!FF!! F.-F.G66G:=G:.find_tensor_attributes..s0[[[TQXYHZHZ[1a&[[[r_)__dict__r)r\tupless r]find_tensor_attributesz:SentenceTransformer.device..find_tensor_attributess([[V_-B-B-D-D[[[ r_)get_members_fnrrN)r\rrJr ) rfr! auto_modelrrrr_named_membersr.)rr(gen first_tuples r]rzSentenceTransformer.devices d1g{ + + -7%, , +))**1 1 + + +    %%5K%LLC +"3ii "1~,,,,  + + +|E******* + +s/%A$B?:BB?B;6B?:B;;B?r c4|jS)zJ Property to get the tokenizer that is used by this model rw tokenizerrs r]r0zSentenceTransformer.tokenizers !!##--r_c8||_dS)zQ Property to set the tokenizer that should be used by this model Nr/r&s r]r0zSentenceTransformer.tokenizers */&&&r_c4|jS)a Returns the maximal input sequence length for the model. Longer inputs will be truncated. Returns: int: The maximal input sequence length. Example: :: from sentence_transformers import SentenceTransformer model = SentenceTransformer("all-mpnet-base-v2") print(model.max_seq_length) # => 384 rwrvrs r]rvz"SentenceTransformer.max_seq_length s"!!##22r_c8||_dS)zs Property to set the maximal input sequence length for the model. Longer inputs will be truncated. Nr3r&s r]rvz"SentenceTransformer.max_seq_lengths /4+++r_ torch.devicecDtd|jS)Nzj`SentenceTransformer._target_device` has been deprecated, please use `SentenceTransformer.device` instead.)rqrrrs r]_target_devicez"SentenceTransformer._target_device#s% x   {r_int | str | torch.device | Nonec0||dSr)r)rrs r]r7z"SentenceTransformer._target_device*s r_cZ |jS#t$rgcYSwxYwr)rw_no_split_modulesAttributeErrorrs r]r;z%SentenceTransformer._no_split_modules.s@ %%''9 9   III   **cZ |jS#t$rgcYSwxYwr)rw_keys_to_ignore_on_saver<rs r]r?z+SentenceTransformer._keys_to_ignore_on_save5s@ %%''? ?   III r=cr|D]3}t|tr|j|cS4dSr)rfr!r*gradient_checkpointing_enable)rgradient_checkpointing_kwargsr\s r]rAz1SentenceTransformer.gradient_checkpointing_enable<sV f fF&+.. f(FFGdeeeee f f fr_)NNNNNNNFNFNNNNNNNr.)&r/r0r1r2rr0r3r4r5r0r6r7r8r0r9r:r;r0r<r:r=r>r?r>r@rArBrCrDrCrErCrFrGrHrIrJrK)rJrI) ..........)rrYrr0rr0rrrrrrrrrrrrrrYrr:rJr)rrrr0rr0rrrrrrrrrrrrrrYrr:rJr)rrrr0rr0rrrrrrrrrr:rrrrYrr:rJr)rrrr0rr0rrrrrrrrrrrrrrYrr:rJr) NNrNrrTFNF)rrrr0rr0rrrrrrrrrr:rr:rrYrr:rJr)rrrJr)rJr)rr rJrK)r'rr(rrJr)r'rr(rrJr)rJr-r)r3r4rJr5)rTr5rJrK)NNrNNrF)rr4rTr5rr0rr0rrrYrrrrrrr:rJr) rmrYrnr-rPrrorrJrK)rbr:rJrK)rJrA)ryrzrJr)rJr|)r@rArJr)rJr)NTNT) rwrYrr0rr:rrrr:rJrK)Nr)rwrYrr0rrrJrK) NNNTrNFFN)rrYrr0r=r0rrrr:rrYrr0rr:rr:rrrJrY) NNTNNFFNNF)rrYr=r0rrrr:rr0rr0rr:rr:rrr;r0rr:rJrY)rrrJr)rrrrYrJr)NFFNNN)r/rYr=r>r8r0r;r0r9r:r<r:rBrCrDrCrErCrJr) rrYr/rYr9r:r;r0rBrCrJr)r/rYr=r>r8r0r;r0r9r:r<r:rBrCrDrCrErCrJr )rJr-)rJr)rJr )rJrK)rJr)rJr5)rr8rJrK)rJr4)0rr __qualname____doc__rrr rrpropertyr6setterr+r0rS staticmethodrXrlrMrrxrr~rrrrwrrrrr*rrrrr|r r{rrr0rvr7r;r?rA __classcell__)rs@r]r-r-8sSffT*..2!)-*.>B#'"'#!&#',0#'.226/3CG8?'^2^2^2^2^2^2^2@#& ),QTNQ+.,/%(X #& ),QTNQ*-,/%(X #& ),QTNQ!$+.%(X #& ),QTNQ+.,/%(X&#'!)-QeNW!%"'%*\\\\\|(((X(  \ \ \ \QQQXQ SSSXS ( ( ( X( TZZZXZ \\\X\ !)!)!)X!)H+//V/V/V/V/Vb\0#'!)-NW%*`````D\6$     4 4 4 4EEEE&444^4:8888<<<<"&"&+/#' UFUFUFUFUFt"&"&+/#'      :\h*#*#*#*#*#X $( ##'B'+#(+/> > > >  > F!##'%)'+#(+/#t%t%t%t%t%l//// , , , , ,( $"'!&.226/35252525252n----B $"'!&.226/3|&|&|&|&|&|///\/+++X+0...X. //// 333X3$4444 X X X fffffffffr_r-)R __future__rrrsrrrrorqrrrrrk collectionsrcollections.abcrr contextlibrmultiprocessingrpathlibr typingr r r r rrr.torch.multiprocessingrJrhuggingface_hubrrrrrtqdm.autonotebookrr!transformers.dynamic_module_utilsrr sentence_transformers.model_cardrr*sentence_transformers.similarity_functionsrrQrr evaluationr fit_mixinrmodelsrr r! peft_mixinr" quantizationr#rtr$r%r&r'r(r)r*r+ getLoggerrrq Sequentialr-rXr_r]r]s-""""""   ######........%%%%%%!!!!!!333333333333 """"""!!!!!!$$$$$$$$$$$$$$$$//////ffffffffbbbbbbbbIIIIII55555555))))))3333333333((((((------                      8 $ $HfHfHfHfHf"-3CHfHfHfHfHfr_