>:jSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSKJ r SSK J r J r SSK Jr SSKJr SSKJrJrJr SSKrSSKJr SSKrSSKJrJr SS KJr SS KJr SS K J!r! SS K"J#r# SS K$J%r% SSK&J'r' SSK(J)r) SSK*J+r+J,r, SSK-J.r. SSK/J0r0 SSK1J2r2 SSK3J4r4 SSK5J6r6 \Rn"\85r91Skr:"SS\%\45r;g)) annotationsN) OrderedDict)CallableIterator)contextmanager)Queue)AnyLiteraloverload)Tensornn)trange)logging) deprecated) SingleInput) BaseModel) Transformer)Pooling)batch_to_devicetruncate_embeddings)deprecated_kwargs)quantize_embeddings)SimilarityFunction)FitMixin) SentenceTransformerModelCardData>int8uint8binaryfloat32ubinarycT^\rSrSr%Sr\rSrS\S'SSS.r S\S '\ "S S 9S;SSSSSS SS SSSSSSS SSS.SSjj5r \ "SS9S=S>Sjj5r \S?S@Sjj5r\S?SASjj5r\S?SBSjj5r\S?SCSjj5r\S?SDSjj5r\S?SESjj5r\S?SFSjj5r\R""5\ "SS9S=S>Sjj55r\SGSj5r\SHSj5r\R,SISj5r\SJSj5r\SKS j5r\SLS!j5r\SJS"j5r\SKS#j5r\SLS$j5r\"S%5SMSNS&jj5rSOSPS'jjr\SQS(j5rSRS)jr\"S*5SSS+j5rSTS,jr\"S-\ S.9STS/j5r!\"SUS0j5r#\"\"S1\ S.9SUS2j55r$\\"S35SVS4j55r%SWSXS5jjr&SYU4S6jjr'SZU4S7jjr(S[S\S8jjr)S]S9jr*S:r+U=r,$)^SentenceTransformer)aP Loads or creates a SentenceTransformer model that can be used to map text and other inputs to dense embeddings. 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 SentenceTransformer 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 SentenceTransformer 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. 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 to encode. 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. use_auth_token (bool or str, optional): Deprecated. Use ``token`` instead. 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``: 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 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 (:class:`~sentence_transformers.sentence_transformer.model_card.SentenceTransformerModelCardData`, 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"``. 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"`` when :attr:`similarity` or :attr:`similarity_pairwise` are first accessed. Defaults to None. truncate_dim (int, optional): The dimension to truncate sentence embeddings to. ``None`` means no truncation. Defaults to None. Example: :: from sentence_transformers import SentenceTransformer # Load a pre-trained SentenceTransformer model model = SentenceTransformer('sentence-transformers/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]]) zsentence-transformers str | None default_huggingface_organizationN)querydocumentzdict[str, str | None]_default_promptsprocessor_kwargs)tokenizer_kwargsFtorch)modulesdevicepromptsdefault_prompt_name cache_foldertrust_remote_coderevisionlocal_files_onlytokenuse_auth_token model_kwargsr* config_kwargsmodel_card_databackendsimilarity_fn_name truncate_dimc>UUlUUlU b+[R"S[5 U b [ S5eU n [ TU]UUUUUUU U U U UUUUUS9 U US;aURSS9 gU(a\SU;aUSURS5S R5;a.[S U55(a[RS 5 ggggg) NzlThe `use_auth_token` argument is deprecated and will be removed in a future release of SentenceTransformers.zZBoth `token` and `use_auth_token` are specified. Please only specify the `token` argument.)model_name_or_pathr-r.r1r2r3r4r5r7r*r8r9r:r/r0)zhkunlp/instructor-basezhkunlp/instructor-largezhkunlp/instructor-xlF)include_prompt/ instructorrc3h# UH(n[U[5(dMURv M* g7fN isinstancerr?).0modules m/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sentence_transformers/sentence_transformer/model.py /SentenceTransformer.__init__..s#[tVz&RY?Z(6((ts22zInstructor 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.)r;r<warningswarn FutureWarning ValueErrorsuper__init__set_pooling_include_promptsplitloweranyloggerwarning)selfr>r-r.r/r0r1r2r3r4r5r6r7r*r8r9r:r;r< __class__s rHrPSentenceTransformer.__init__s2#5(  % MM~   p#E 1%/-%-'+ 3  "  !n n  + +5 + A )) 2 8 8 =a @ F F HH[t[[[G\I* inputs) sentencesc vUcUcSUR;aSnUR"SUUUUUUUUU U U U U USS.UD6$)at Computes embeddings specifically optimized for query representation. This method is a specialized version of :meth:`encode` that differs in exactly two ways: 1. If no ``prompt_name`` or ``prompt`` is provided, it uses a predefined "query" prompt, if available in the model's ``prompts`` dictionary. 2. It sets the ``task`` to "query". If the model has a :class:`~sentence_transformers.base.modules.Router` module, it will use the "query" task type to route the input through the appropriate submodules. .. tip:: Adjusting ``batch_size`` can significantly improve processing speed. The optimal value depends on your hardware, model size, precision, and input length. Benchmark a few batch sizes on a small subset of your data to find the best value. All other parameters are identical to :meth:`encode`. See :meth:`encode` for the full parameter documentation. r'r[ prompt_nameprompt batch_sizeshow_progress_bar output_value precisionconvert_to_numpyconvert_to_tensorr.normalize_embeddingsr<pool chunk_sizetaskr/encoderWr[r_r`rarbrcrdrerfr.rgr<rhrikwargss rH encode_query SentenceTransformer.encode_queryslJ  6>g6M!K{{ #!/%-/!5%! !  rZc Uc UcSHnUUR;dMUn O UR"SUUUUUUUUU U U U U USS.UD6$)a Computes embeddings specifically optimized for document/passage representation. This method is a specialized version of :meth:`encode` that differs in exactly two ways: 1. If no ``prompt_name`` or ``prompt`` is provided, it uses the first available prompt from the following candidates: ``"document"``, ``"passage"``, ``"corpus"`` (checked in that order). 2. It sets the ``task`` to "document". If the model has a :class:`~sentence_transformers.base.modules.Router` module, it will use the "document" task type to route the input through the appropriate submodules. .. tip:: Adjusting ``batch_size`` can significantly improve processing speed. The optimal value depends on your hardware, model size, precision, and input length. Benchmark a few batch sizes on a small subset of your data to find the best value. All other parameters are identical to :meth:`encode`. See :meth:`encode` for the full parameter documentation. )r(passagecorpusr(r^rkrl)rWr[r_r`rarbrcrdrerfr.rgr<rhrirocandidate_prompt_names rHencode_document#SentenceTransformer.encode_documents~J  6>)J%(DLL8"7K*K {{ #!/%-/!5%! !  rZc grCrkrns rHrmSentenceTransformer.encodeR$rZc grCrkrns rHrmryfs$rZc grCrkrns rHrmryzrzrZc grCrkrns rHrmrys$rZc grCrkrns rHrmrys$#&rZc grCrkrns rHrmrys$ rZc grCrkrns rHrmryrzrZc URRS:XadUR(dSSSKJn [ US5(a<[ UR S5(a!UR RUSS9 SUlUc5[R5[R[R4;nU (aSnUS:waSn SnUS::a[S US 35eURU5nU(aU/nOO[U[ 5(d:[U["R$5(aUR'5O [!U5nUR)5n[+U5[+U5- S 1- =n(as[UR,R.S [!U5S 3U(a#SUR,R.SUS 3-5eSUR,R.S3-5eUb U[0;a[SU<S[035eU c$[U [ 5(a>[3U 5S:a/UR4"U4UU U UUUUUUUU U U S. UD6nU(aUSnU$UR7X25nU c URn UR9U 5 UR;5 U bU O UR<n /n["R>"UVs/sHnURAU5*PM sn5nURC5(aUREU5nUVs/sHnUUPM nnURRS:Hn[GS[3U5USU(+S9GHnUUUU-nURH"U4SU0UD6nU(aURKU5n[MUU 5nURN"U40UD6nU(a[PRR"U5nU b[UUSU 5US'US:Xa/n[WUUUS5Hlunn [3U 5S- n!U!S:a;U U!RY5S:Xa$U!S-n!U!S:aU U!RY5S:XaM$UR[USU!S-5 Mn OUcW/n[][3US55H9n0n"UR_5Hun#n$U$UU"U#'M UR[U"5 M; OLUUnU (a)[RbRdRgUSSS9nU(aURi5nURkU5 GM ["R>"U5Vs/sHnUUPM nnU(aU(aUS:wa [mUUS9nU (a[3U5(aO[U["R$5(a[Rn"U5nGOF[Rp"U5nGO.[Rr"/URS9nGO U(a[U["R$5(dU(aeUSRt[Rv:XaD["Rx"UV%s/sH!n%U%R{5R}5PM# sn%5nO{["Rx"UV%s/sHn%U%R}5PM sn%5nOE[U["R$5(a&UV&s/sHn&[Rn"U&5PM nn&U(aUSnU$s snfs snf![`a U$U"U#'GMf=fs snfs sn%fs sn%fs sn&f)ap Computes embeddings for the given inputs. .. tip:: If you are unsure whether you should use :meth:`encode`, :meth:`encode_query`, or :meth:`encode_document`, your best bet is to use :meth:`encode_query` and :meth:`encode_document` for Information Retrieval tasks with clear query and document/passage distinction, and use :meth:`encode` for all other tasks. Note that :meth:`encode` is the most general method and can be used for any task, including Information Retrieval, and that if the model was not trained with predefined prompts and/or task types, then all three methods will return identical embeddings. .. tip:: Adjusting ``batch_size`` can significantly improve processing speed. The optimal value depends on your hardware, model size, precision, and input length. Benchmark a few batch sizes on a small subset of your data to find the best value. Args: inputs: The inputs to embed. Can be a string, a list of strings, or multimodal inputs (dicts, images, arrays). prompt_name (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 (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 encoding. Defaults to None, in which case the progress bar will be shown if the logger's effective level is INFO or DEBUG. output_value (Optional[Literal["sentence_embedding", "token_embeddings"]], optional): The type of embeddings to return. precision (Literal["float32", "int8", "uint8", "binary", "ubinary"], optional): The precision to use for the embeddings. convert_to_numpy (bool, optional): Whether the output should be a list of numpy vectors. convert_to_tensor (bool, optional): Whether the output should be one large tensor. device (str, torch.device, list, or None, optional): Device(s) to use for computation. Can be: - A single device string (e.g., "cuda:0", "cpu") for single-process encoding - A list of device strings (e.g., ["cuda:0", "cuda:1"], ["cpu", "cpu", "cpu", "cpu"]) to distribute encoding across multiple processes - None to auto-detect available device for single-process encoding If a list is provided, multi-process encoding will be used. Defaults to None. normalize_embeddings (bool, optional): Whether to normalize returned vectors to have length 1. truncate_dim (int, optional): The dimension to truncate sentence embeddings to. pool (Dict[Literal["input", "output", "processes"], Any], optional): A pool created by ``start_multi_process_pool()``. chunk_size (int, optional): Size of chunks for multi-process encoding. **kwargs: Additional keyword arguments to pass to the model's ``preprocess`` and ``forward`` methods. Returns: Union[List[Tensor], ndarray, Tensor, dict[str, Tensor], list[dict[str, Tensor]]]: By default, a 2d numpy array with shape [num_inputs, output_dimension] is returned. If ``output_value`` is ``None``, a list of dicts (or a single dict for singular input) is returned. hpurNwrap_in_hpu_graphT)disable_tensor_cacheFsentence_embeddingz+batch_size must be a positive integer, got .rjzZ.encode() has been called with additional keyword arguments that this model does not use: z. zAs per zA.get_model_kwargs(), the valid additional keyword arguments are: zQ.get_model_kwargs(), this model does not accept any additional keyword arguments.z Precision z" is not supported, must be one of ) rbrhr.rir_r`rarcrdrerfrgr<Batchesdescdisabler`token_embeddingsattention_maskr)pdimr )rd)r.)?r.typeis_hpu_graph_enabledhabana_frameworks.torchr,hasattrrrrUgetEffectiveLevelrINFODEBUGrNis_singular_inputrElistnpndarraytolistget_model_kwargssetrX__name__ALLOWED_PRECISIONSlen_multi_process_resolve_prompttoevalr<argsort _input_length_can_flatten_inputs_interleave_sorted_indicesr preprocess_pad_features_for_hpurforwardcopydeepcopyrzipitemappendrangeitems TypeErrorr functional normalizecpuextendr from_numpystacktensordtypebfloat16asarrayfloatnumpy)'rWr[r_r`rarbrcrdrerfr.rgr<rhrirohtrr7 unused_kwargs embeddingsall_embeddingssenlength_sorted_idxidx inputs_sortedis_hpu start_index inputs_batchfeatures out_features token_emb attention last_mask_id batch_itemnamevalueemb embeddings' rHrmrys\ ;;  u $T-F-F 0r5!!gbff6I&J&J((D(I,0)  $ & 8 8 :w||W]]>[ [  $  / / % $  ?J:,VWXY Y!226: XFFD))(262::(F(FV]]_DQWLF,,. K#l*;;vhF F= F>>**+,FGKLYGZF[[]^$dnn5566wyExFFGH  #4>>#:#:";[[F  '3'?|TEVEV JJF'SFS););C)@(@F'ST  # # % % $ ? ?@Q R 0AB0A0A B!!U*!!S%7)ar]rsK({Z7OPL|MFMfMH55h?&x8H<<;F;L#}}\: '5H !56 6 1211 ,/ \0JLYiLj,k(Iy#&y>A#5L&*y/F/K/K/MQR/R$) '*y/F/K/K/MQR/R%%i0B,2B&CD -l %  \2F%G!HIC!#J'3'9'9'; e5/4SzJt,(< %%j1J*,7 '!&!4!4!>!>zQTU!>!VJ#!+!1J  ! !* -UtX:<DU9VW9V#.-9VW iI,B09UN >""nbjj99%*%5%5n%EN%*[[%@N!&b!E nbjj99!nQ&7&=&=&O%'ZZP^0_P^1B1B1DP^0_%`N%'ZZ0W0W%XN  3 3KYZ>ie..y9>NZ +A.NW(TCF )5/4Jt,5X 1`0WZs6\\!/\& \=#(]'], ] &\: 9\: cLSU;aU$USRupUS:a-S[R"[R"U55-OSnX2- nUS:XaU$[R "US[R "X4[RS94S5US'[R "US[R"X4[RS94S5US'SU;aA[R "US[R"X4[RS94S5US'U$)zFPad input features to the next power of 2 for HPU graph compatibility. input_idsrr)rrtoken_type_ids) shapemathceillog2r,catonesrzeros)rraseq_len padded_lenpad_lens rHr)SentenceTransformer._pad_features_for_hpus h &O&{399 ;BQ;Q$))DIIg$677A & a<O % k "EJJ /DEJJ$W XZ\! &+YY & 'j5JRWR\R\)] ^`b& !" x ').*+U[[*9NV[V`V`-abdf*H% &rZc^URc[RUlUR$)zyReturn the name of the similarity function. If not previously set, accessing this property defaults it to ``"cosine"``. )_similarity_fn_namerCOSINEr;rWs rHr;&SentenceTransformer.similarity_fn_names*  # # +&8&?&?D #'''rZc[U[5(a URnUb6[R"U5Ul[R "U5UlXlgrC)rErrto_similarity_fn _similarityto_similarity_pairwise_fn_similarity_pairwiser)rWrs rHr;rsN e/ 0 0KKE  1BB5ID (:(T(TUZ([D %#( rZcgrCrkrW embeddings1 embeddings2s rH similaritySentenceTransformer.similaritysNQrZcgrCrkrs rHrrspsrZc2UR UR$)z Return a function that computes 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. )r;rrs rHrrs rZcgrCrkrs rHsimilarity_pairwise'SentenceTransformer.similarity_pairwisesWZrZcgrCrkrs rHrr srZc2UR UR$)z` Return a function that computes the pairwise similarity between two collections of embeddings. )r;rrs rHrrs (((rZzThe `encode_multi_process` method has been deprecated, and its functionality has been integrated into `encode`. You can now call `encode` with the same parameters to achieve multi-process encoding.c 8URUUUUUSUSSU U UUS9 $)z .. warning:: This method is deprecated. You can now call :meth:`SentenceTransformer.encode` with the same parameters instead, which will automatically handle multi-process encoding using the provided ``pool``. rTF) r_r`rarbrcrdrerfrgr<rhri)rm) rWr\rhr_r`rarirbrdrgr<s rHencode_multi_process(SentenceTransformer.encode_multi_processsA,{{ #!/-!#!5%!  rZc URSS5nURSS5nSUS'Sn Uc([U[5(aURU5nSn UcG[ [ R "[U5[US5- S- 5S5n[US 5nUS n US n S n [[S [U5U55HupXX-nU RXU/5 M [[U S -SU(+S9Vs/sHoR5PM snSS9nUVs/sHnUS PM nnU(a[US [5(a)[[RR!U55nO[US ["R$5(a["R&"U5nOs[US [(R*5(a[(R,"US S9nO;U(a["R."/5nOU(a[(R0"/5nUU (aUR3U5 $$s snfs snf!U (aUR3U5 ff=f)zInternal method for multi-process encoding. Either ``pool`` or ``device`` (as a list) must be provided. If ``pool`` is ``None`` and ``device`` is a list, a temporary pool is created and cleaned up after encoding. rfFrerbT processes irinputoutputrrChunksrc US$Nrrk)xs rH4SentenceTransformer._multi_process..jsadrZ)key)axis)getrErstart_multi_process_poolminrrrmax enumeraterputsortedr itertoolschain from_iterabler,r rrr concatenaterarraystop_multi_process_pool)rWr[rbrhr.ri encode_kwargsrfre created_pool input_queue output_queuechunk_id chunk_startchunk_ output_listrrs rHr"SentenceTransformer._multi_process@s-*--.A5I(,,-?G-2 )* >+&)+J>jmT22!%ioo&C&CJ&O!PJ 1 u||<r5r1r3r2r4r7r*r8 shared_kwargstransformer_modelr-rQ is_causal_lm pooling_modes rH_load_default_modules)SentenceTransformer._load_default_modulessKB!2 0  -9,@(-(FgFgZfFg 0@0H,m,NsQ^NsbrNs-:-B)=)Hj=Hj\iHj ' "%-'LL  %%  / /3E E&--F67((+44]C7FK6  +7;FL NN7#4#L#L#NP\] ^  / /0B / V{rZc>[TU]U5 URcURSS5UlUR cURSS5UlggNr;r<)rO_parse_model_configrr r;r<)rW model_configrXs rHr\'SentenceTransformer._parse_model_config8sX #L1  # # +&2&6&67KT&RD #    $ , 0 0 FD  %rZcz>[TU]5SUR0-nURbURUS'U$r[)rO_get_model_configr;r<)rWrQrXs rHr`%SentenceTransformer._get_model_config?sH*, $"9"90      (%)%6%6F> " rZc 4URUUUUUUUUU 5 $rC)rX) rWr>r5r1r3r2r4r7r*r8 model_types rH_load_converted_modules+SentenceTransformer._load_converted_modulesGs2))           rZc lURRnUR5nSUSUSUSUS3 $)Nz## Testing this pull request You can test this pull request before merging by loading the model from this PR with the `revision` argument: ```python from sentence_transformers import zO # NOTE: Update this to the number of your pull request pr_number = 2 model = z( "z5", revision=f"refs/pr/{pr_number}", backend="a", ) # Verify that everything works as expected embeddings = model.encode(["The weather is lovely today.", "It's so sunny outside!", "He drove to the stadium."]) print(embeddings.shape) similarities = model.similarity(embeddings, embeddings) print(similarities) ``` --- *This PR was auto-generated with [`push_to_hub`](https://sbert.net/docs/package_reference/sentence_transformer/SentenceTransformer.html#sentence_transformers.SentenceTransformer.push_to_hub).* )rXr get_backend)rWrepo_id class_namer:s rH_push_to_hub_usage_tip*SentenceTransformer._push_to_hub_usage_tipasZ^^,, ""$#$.,/    YY rZ)rrrrr;r<rC)&r>r%r-zlist[nn.Module] | Noner.r%r/zdict[str, str] | Noner0r%r1r%r2boolr3r%r4rlr5bool | str | Noner6rmr7dict[str, Any] | Noner*rnr8rnr9z'SentenceTransformerModelCardData | Noner:z$Literal['torch', 'onnx', 'openvino']r;NLiteral['cosine', 'dot', 'euclidean', 'manhattan'] | SimilarityFunction | Noner< int | NonereturnNone) NN Nrr TFNFNNN)r[list[SingleInput] | SingleInputr_r%r`r%raintrb bool | Nonercz8Literal['sentence_embedding', 'token_embeddings'] | Nonerd8Literal['float32', 'int8', 'uint8', 'binary', 'ubinary']rerlrfrlr.%str | list[str | torch.device] | Nonergrlr<rprh9dict[Literal['input', 'output', 'processes'], Any] | NonerirprqzPlist[Tensor] | np.ndarray | Tensor | dict[str, Tensor] | list[dict[str, Tensor]]) .............)r[rr_r%r`r%rarurbrvrc1Literal['sentence_embedding', 'token_embeddings']rdrwreLiteral[False]rfrlr.rxrgrlr<rprhryrirprqr )r[rtr_r%r`r%rarurbrvrcLiteral['sentence_embedding']rdrwre Literal[True]rfr{r.rxrgrlr<rprhryrirprq np.ndarray)r[rtr_r%r`r%rarurbrvrcr|rdrwrerlrfr}r.rxrgrlr<rprhryrirprqr )r[list[SingleInput]r_r%r`r%rarurbrvrcrzrdrwrerlrfrlr.rxrgrlr<rprhryrirprqz list[Tensor])r[rr_r%r`r%rarurbrvrcrrrdrwrerlrfrlr.rxrgrlr<rprhryrirprqzlist[dict[str, Tensor]])r[rr_r%r`r%rarurbrvrcrrrdrwrerlrfrlr.rxrgrlr<rprhryrirprqdict[str, Tensor])r[rr_r%r`r%rarurbrvrczLiteral['token_embeddings']rdrwrerlrfrlr.rxrgrlr<rprhryrirprqr )rrrqr)rqz2Literal['cosine', 'dot', 'euclidean', 'manhattan'])rrorqrr)rr rr rqr )rnpt.NDArray[np.float32]rrrqr )rqzVCallable[[Tensor | npt.NDArray[np.float32], Tensor | npt.NDArray[np.float32]], Tensor])NNrsNNr FN)r\z list[str]rhz2dict[Literal['input', 'output', 'processes'], Any]r_r%r`r%rarurirprbrvrdrwrgrlr<rprqr~)TNNN) r[rrbrvrhryr.rxrirprqzlist | Tensor | np.ndarray) r&strr'r#rrr(rrqrr)r?rlrqrr)rqr)rqrp)r<rprqzIterator[None])rFrrqr#)NFFNNN)r>rr5rmr1r%r3r%r2rlr4rlr7rnr*rnr8rnrqDtuple[list[nn.Module] | OrderedDict[str, nn.Module], dict[str, Any]])r]dict[str, Any]rqrr)rqr)NFFNNNN)r>rr5rmr1r%r3r%r2rlr4rlr7rnr*rnr8rnrcr%rqr)rhrrqr)-r __module__ __qualname____firstlineno____doc__rmodel_card_data_classr&__annotations__r)rrPrprvr rmr,inference_mode staticmethodrpropertyr;setterrrrrrr)rQr.r1rMr2rrrCrGrXr\r`rdrj__static_attributes__ __classcell__)rXs@rHr#r#)s _B=3J$jJ8<$.O+O(:;*.F+/!)-*.#'"'#!&#',0.226/3CG8?mq#'+F&F( F  F ' F(F!F FFF!F*F,F0F -!F"A#F$6%F(k)F*!+F, -FF<FP*#'!)-QeNW!%"'8<%*#'JN!%8 /8  8  8  8 ' 8 O8 L8 8  8 68 #8 !8 H8 8 " Z#8 +8 t*#'!)-QeNW!%"'8<%*#'JN!%; /;  ;  ;  ; ' ; O; L; ;  ; 6; #; !; H; ; " Z#; +; |#& ),JMNQ+."%8;%(#&JM!$     ' HL) 6#!H" #&#& ),69NQ*-,/8;%(#&JM!$/     ' 4L(*6#!H" #&#& ),69NQ!$+.8;%(#&JM!$/     ' 4L)6#!H" #&#& ),JMNQ!$"%8;%(#&JM!$!     ' HL 6#!H" #&#& ), NQ!$"%8;%(#&JM!$&!& & &  & ' &&L&& &6&#&!&H&&" !#&&&#& ), NQ!$"%8;%(#&JM!$        '   L    6 # ! H  " #  &#& ),47NQ!$"%8;%(#&JM!$     ' 2L 6#!H" #& *#'!)-QeNW!%"'8<%*#'JN!%g/g g g  g ' gOgLgg g6g#g!gHgg" Z#g+gR.(()c) ))QQ ss   ZZ 2AX ) _)) `#'!!%)-NW%*#'    A          '  L  #  !       J*.JN83!>3'>3H >3 6 >3  >3 $>3@#6EJ[` . kl8m84f. .44:^  de/f/ $"'!&.226/3@@!@! @  @  @@,@0@-@ N@DG $"'!&.226/3!%  ! !       , 0 -   N 4rZr#)< __future__rrrrrr$rK collectionsrcollections.abcrr contextlibrmultiprocessingrtypingr r r rr numpy.typingnptr,r r tqdm.autonotebookrtransformers.utilstransformers_loggingtyping_extensionsr)sentence_transformers.base.modality_typesr sentence_transformers.base.modelr"sentence_transformers.base.modulesr2sentence_transformers.sentence_transformer.modulesrsentence_transformers.utilrr%sentence_transformers.util.decoratorsr'sentence_transformers.util.quantizationr%sentence_transformers.util.similarityr fit_mixinr model_cardr get_loggerrrUrr#rkrZrHrs"  #.%!)) $>(A6:FKCGD8  ( ( 2FT)XTrZ