>:jvSSKJr SSKrSSKrSSKrSSKrSSKJr SSKJ r SSK J r J r J r SSKrSSKJ r SSKrSSKJrJr SSKJr SSKJrJr SS KJr SS KJr SS KJr SS K J!r! SS K"J#r# SSK$J%r% SSK&J'r' SSK(J)r) SSK*J+r+J,r, SSK-J.r.J/r/ SSK0J1r1 SSK2J3r3 \Rh"\55r6"SS\!5r7g)) annotationsN)Callable)Queue)AnyLiteraloverload)Tensornn)trange) AutoConfigPretrainedConfig)PreTrainedModel)logging) deprecated) BaseModel) TextInput) Transformer)Pooling)SparseEncoderModelCardData)SparseAutoEncoder SpladePooling)batch_to_deviceselect_max_active_dims)deprecated_kwargs)SimilarityFunctionc^\rSrSr%Sr\rSrS\S'SSS.r S\S 'S r \ "S S 9S4SSSSSS SS SSSSSSSSS.S5U4Sjjjj5r \ "SS9S6S7Sjj5r \ "SS9S6S7Sjj5r\ "SS9S6S7Sjj5rS8U4SjjrS9U4Sjjr\S:Sj5r\R(S;Sj5rSSj5r\S?Sj5r\S=Sj5r\S>Sj5r\S?S j5rS@SAS!jjr\SBS"j5rSCS#jr\"S$\S%9SCS&j5rSDSES'jjr SFSGS(jjr!\SHS)j5r"\SIU4S*jj5r#\#R(SJS+j5r#\SKU4S,jj5r$SLS-jr%\SCS.j5r&\&R(SMS/j5r&\SNS0j5r'S4SOS1jjr(SPS2jr)S3r*U=r+$)Q SparseEncoder#a^ Loads or creates a SparseEncoder model that can be used to map text to sparse 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 SparseEncoder 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 SparseEncoder 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. 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.sparse_encoder.model_card.SparseEncoderModelCardData`, 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. max_active_dims (int, optional): The maximum number of active (non-zero) dimensions in the output of the model. ``None`` means no limit, which can be slow or memory-intensive if your model wasn't (yet) finetuned to high sparsity. Defaults to None. Example: :: from sentence_transformers import SparseEncoder # Load a pre-trained SparseEncoder model model = SparseEncoder('naver/splade-cocondenser-ensembledistil') # 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, 30522) # Get the similarity scores between all sentences similarities = model.similarity(embeddings, embeddings) print(similarities) # tensor([[ 35.629, 9.154, 0.098], # [ 9.154, 27.478, 0.019], # [ 0.098, 0.019, 29.553]]) zsparse-encoder str | None default_huggingface_organizationN)querydocumentzdict[str, str | None]_default_promptssparse_encoder_model_idprocessor_kwargs)tokenizer_kwargsFtorch)modulesdevicepromptsdefault_prompt_name cache_foldertrust_remote_coderevisionlocal_files_onlytoken model_kwargsr% config_kwargsmodel_card_databackendsimilarity_fn_namemax_active_dimsc&>UUl[TU] UUUUUUU U U U U UUUUS9 U UbUS::a[SUS35eUUlUcJUR R 5H+n[U[5(dMURUl g gg)N)model_name_or_pathr(r)r,r-r.r/r0r1r%r2r3r4r*r+rz0max_active_dims must be a positive integer, got .) r5super__init__ ValueErrorr6_modulesvalues isinstancerk)selfr8r(r)r*r+r,r-r.r/r0r1r%r2r3r4r5r6module __class__s g/home/mande/repo/quber/.venv/lib/python3.13/site-packages/sentence_transformers/sparse_encoder/model.pyr;SparseEncoder.__init__s0#5 1%/-%-'+ 3  $  &?a+?OP_O``abc c.  "--..0f&788+188D(1 #inputs) sentencesc  rUcUcSUR;aSnUR"SUUUUUUUUU U U U SS. U D6$)aw 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. Example: :: from sentence_transformers import SparseEncoder # Load a pre-trained SparseEncoder model model = SparseEncoder("naver/splade-cocondenser-ensembledistil") # Encode some texts queries = [ "What are the effects of climate change?", "History of artificial intelligence", "Technical specifications product XYZ", ] embeddings = model.encode_query(queries) print(embeddings.shape) # (3, 30522) r! rG prompt_nameprompt batch_sizeshow_progress_barconvert_to_tensorconvert_to_sparse_tensor save_to_cpur)r6pool chunk_sizetaskr*encode)rArGrKrLrMrNrOrPrQr)r6rRrSkwargss rD encode_querySparseEncoder.encode_querysfj  6>g6M!K{{ #!//%=#+!   rFc  UcUcSHnXR;dMUn O UR"SUUUUUUUUU U U U SS. U D6$)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. Example: :: from sentence_transformers import SparseEncoder # Load a pre-trained SparseEncoder model model = SparseEncoder("naver/splade-cocondenser-ensembledistil") # Encode some texts sentences = [ "This research paper discusses the effects of climate change on marine life.", "The article explores the history of artificial intelligence development.", "This document contains technical specifications for the new product line.", ] embeddings = model.encode_document(sentences) print(embeddings.shape) # (3, 30522) )r"passagecorpusr"rJrUrV)rArGrKrLrMrNrOrPrQr)r6rRrSrXcandidate_prompt_names rDencode_documentSparseEncoder.encode_document svj  6>)J%(LL8"7K*K {{ #!//%=#+!   rFc  PUc5[R5[R[R4;nUS::a[ SUS35eUR U5nU(aU/nOO[U[5(d:[U[R5(aUR5O [U5nUR5n[U 5[U5- S1- =n(as[ URRS[U5S3U(a#SURRS US3-5eSURRS 3-5eU c$[U [5(a<[!U 5S:a-UR""SUUU U U UUUUUS U S . U D6nU(aUSnU$UR%X25nU c UR&n UR)U 5 UR+5 U bU O UR,n [/U 5nU bU US '/n[R0"UVs/sHnUR3U5*PM sn5nUR55(aUR7U5nUVs/sHnUUPM nn[9S[!U5USU(+S9HnUUUU-nUR:"U4SU0U D6n[=UU 5n[>R@"5 URB"U40UD6SnU b [EUU S9nSSS5 U(aWRG5nU(aWRI5nURKW5 M [R0"U5Vs/sHnUUPM nnU(as[!U5S:XaN[>RL"/UR&S9nU(aURG5nU(aURI5nO[>RN"U5nU(aUSnU$s snfs snf!,(df  GN =fs snf)ak Computes sparse sentence embeddings. .. 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 (Union[str, List[str]]): The texts to embed. 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. convert_to_tensor (bool, optional): Whether the output should be a single stacked tensor (True) or a list of individual tensors (False). Sparse tensors may be challenging to slice, so this allows you to output lists of tensors instead. Defaults to True. convert_to_sparse_tensor (bool, optional): Whether the output should be in the format of a sparse (COO) tensor. Defaults to True. save_to_cpu (bool, optional): Whether the output should be moved to cpu or stay on the device it has been computed on. Defaults to False. 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. max_active_dims (int, optional): The maximum number of active (non-zero) dimensions in the output of the model. ``None`` means the value from the model's config will be used. Defaults to None. If also None in the model's config, there will be no limit on the number of active dimensions, which can be slow or memory-intensive if your model wasn't (yet) finetuned to high sparsity. pool (dict, optional): A pool created by :meth:`start_multi_process_pool` for multi-process encoding. If provided, the encoding will be distributed across multiple processes. This is recommended for large datasets and when multiple GPUs are available. Defaults to None. chunk_size (int, optional): Size of chunks for multi-process encoding. Only used with multiprocessing, i.e. when ``pool`` is not None or ``device`` is a list. If None, a sensible default is calculated. Defaults to None. Returns: Union[list[Tensor], Tensor]: By default, a 2d torch sparse tensor with shape [num_inputs, output_dimension] is returned. If only one string input is provided, then the output is a 1d tensor with shape [output_dimension]. If ``convert_to_tensor`` is False, a list of individual tensors is returned instead. Example: :: from sentence_transformers import SparseEncoder # Load a pre-trained SparseEncoder model model = SparseEncoder("naver/splade-cocondenser-ensembledistil") # 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, 30522) Nrz+batch_size must be a positive integer, got r9rTzZ.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.T) rGrNrRr)rSrKrLrMrOrPrQr6r6BatchesdescdisablerLsentence_embedding)r6)r)rU)(loggergetEffectiveLevelrINFODEBUGr<is_singular_inputr?listnpndarraytolistget_model_kwargssetrC__name__len_multi_process_resolve_promptr)toevalr6dictargsort _input_length_can_flatten_inputs_interleave_sorted_indicesr preprocessrr'inference_modeforwardr to_sparsecpuextendtensorstack)rArGrKrLrMrNrOrPrQr)r6rRrSrXrkr1 unused_kwargs embeddingsforward_kwargsall_embeddingssenlength_sorted_idxidx inputs_sorted start_index inputs_batchfeaturess rDrWSparseEncoder.encodeVs/F  $ & 8 8 :  ?!  ?J:,VWXY Y!226: XFFD))(262::(F(FV]]_DQWLF,,. K#l*;;vhF F= F>>**+,FGKLYGZF[[]^$dnn5566wyExFFGH  #4>>#:#:";[[F  -<-H/dNbNbf  &0?N, -JJF'SFS););C)@(@F'ST  # # % % $ ? ?@Q R 0AB0A0A B!!S[*9ZkVklK({Z7OPL|MFMfMH&x8H%%'!\\(EnEFZ[ ".!7 Tc!dJ ( ('113 '^^-  ! !* -!m$:<DU9VW9V#.-9VW >"a'!&b!E+%3%=%=%?N%3%7%7%9N!&^!< +A.NM(TC('Xs-P:P '$P.P# P c>>[TU]5SUR0-$Nr5)r:_get_model_config_similarity_fn_namerArCs rDrSparseEncoder._get_model_config&s(w(* $":":.   rFcn>[TU]U5 URcURSS5Ulggr)r:_parse_model_configrgetr5)rA model_configrCs rDr!SparseEncoder._parse_model_config+s7 #L1  # # +&2&6&67KT&RD # ,rFc^URc[RUlUR$)aReturn the name of the similarity function used by :meth:`SparseEncoder.similarity` and :meth:`SparseEncoder.similarity_pairwise`. Returns: Literal["cosine", "dot", "euclidean", "manhattan"]: The name of the similarity function. Defaults to "dot" when first accessed if not explicitly set. Example: >>> model = SparseEncoder("naver/splade-cocondenser-ensembledistil") >>> model.similarity_fn_name 'dot' )rrDOTr5rAs rDr5 SparseEncoder.similarity_fn_name0s*  # # +&8&<&>> model = SparseEncoder("naver/splade-cocondenser-ensembledistil") >>> 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) >>> model.similarity(embeddings, embeddings) tensor([[ 30.953, 12.871, 0.000, 0.011], [ 12.871, 27.505, 0.580, 0.578], [ 0.000, 0.580, 36.068, 15.301], [ 0.011, 0.578, 15.301, 39.466]]) >>> model.similarity_fn_name "dot" >>> model.similarity_fn_name = "cosine" >>> model.similarity(embeddings, embeddings) tensor([[ 1.000, 0.441, 0.000, 0.000], [ 0.441, 1.000, 0.018, 0.018], [ 0.000, 0.018, 1.000, 0.406], [ 0.000, 0.018, 0.406, 1.000]]) )r5rrs rDrr`sR rFcgrrUrs rDsimilarity_pairwise!SparseEncoder.similarity_pairwisesWZrFcgrrUrs rDrrsrFc2UR UR$)a, Compute the similarity between two collections of embeddings. The output will be a vector with the similarity scores between each pair of embeddings. This method supports only embeddings with fp32 precision and does not accommodate quantized 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 = SparseEncoder("naver/splade-cocondenser-ensembledistil") >>> 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, convert_to_sparse_tensor=False) >>> model.similarity_pairwise(embeddings[::2], embeddings[1::2]) tensor([12.871, 15.301]) >>> model.similarity_fn_name "dot" >>> model.similarity_fn_name = "cosine" >>> model.similarity_pairwise(embeddings[::2], embeddings[1::2]) tensor([0.441, 0.406]) )r5rrs rDrrsH (((rFc URSS5nSUS'SnUc([U[5(aURU5nSnUcG[ [ R "[U5[US5- S- 5S5n[US5nUS n US n U(a"[ R "[U5U- 5OS n [U 5H n X-n XX-nU RXU/5 M" [[U S U(+S 9Vs/sHoR5PM snSS9nUH n[US[5(dMUSe UVs/sHnUSPM nnU(a[US [5(a)[[RR!U55nO[US ["R$5(a["R&"U5nOT[US [(R*5(a[(R,"US S9nOU(a["R$"5nUU(aUR/U5 $$s snfs snf!U(aUR/U5 ff=f)zInternal method for multi-process encoding. Distributes encoding across multiple processes using the provided pool or list of devices. If a pool is not provided but ``device`` is a list, a pool is created and cleaned up automatically. rOFrNT processes iinputoutputrChunksrcc US$)NrrU)xs rD.SparseEncoder._multi_process..sadrF)key)axis)rr?rlstart_multi_process_poolminmathceilrsmaxrangeputsortedr Exception itertoolschain from_iterabler'r catrmrn concatenatestop_multi_process_pool)rArGrNrRr)rS encode_kwargsrO created_pool input_queue output_queue num_chunkschunk_id chunk_startchunk_ output_listrrs rDrtSparseEncoder._multi_processs3*--.A5I-2 )* >+&)+J>jmT22!%ioo&C&CJ&O!PJ 1 u||<getattrcallable)rA output_dimrBnamemethods rDr%SparseEncoder.get_embedding_dimensionsm t}}3356F !t4F##!'J%7rFz\The `get_sentence_embedding_dimension` method has been renamed to `get_embedding_dimension`.)categoryc"UR5$r)rrs rDr.SparseEncoder.get_sentence_embedding_dimension.s ++--rFc UUUUS.n 0U EU=(d 0En0U EU=(d 0En0U EU =(d 0En [R"U4SU0U D6n [S[U SS5=(d /55n U (a;[ USUUUU UR S9n [ RS5 [S S 9nX/nOv[ RS 5 [ US UUUU UR S9n [U R5S S9n[UR5SUR5-SSS9nU UU/nU(dURRXS9 U04$)a Creates a simple transformer-based model and returns the modules. For models with a ForMaskedLM architecture, uses SpladePooling with 'max' strategy. For regular Transformers, uses a CSR implementation (Pooling + SparseAutoEncoder) by default. 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. has_modules (bool, optional): Whether the model has modules.json. Defaults to False. Returns: tuple[list[nn.Module], dict[str, Any]]: The modules and an empty kwargs dict. r0r-r.r/ cache_dirc3B# UHoRS5v M g7f) ForMaskedLMN)endswith).0archs rD 6SparseEncoder._load_default_modules..csqDpD==77Dps architecturesNz fill-mask)transformer_taskrr1r%r2r4z.Detected MLM architecture, using SpladePoolingr)pooling_strategyz`No MLM architecture detected, using default Transformer + mean Pooling + SparseAutoEncoder (CSR)zfeature-extractionmean) pooling_modei input_dim hidden_dimr@k_aux)r.)r from_pretrainedanyrrr4rginforrrrr3set_base_model)rAr8r0r,r.r-r/r1r%r2 shared_kwargsconfig is_mlm_modeltransformer_model pooling_modelr(poolingsaes rD_load_default_modules#SparseEncoder._load_default_modules5sB!2 0  A-@L,>B@ HmH0@0FBHB=B]-@bB #-#=#= $ *6$ :G$ qGFTceiDjDpnpDpqq  +"!,&)!1+ !  KKH I)5AM(8G KKr !,"!5&)!1+ ! /GGIX^_G#!99;w>>@@ C )'37G  / /0B / V{rFc :U S:waURUUUUUUUUU S9 $UUUUS.n 0U EU=(d 0En0U EU=(d 0En0U EU =(d 0En [RS5 URUUUUUUUUU S9 uol[ U R 55n Sn [U 5H&n[US5(dMUR5n O U c [S5e[U SU -U S-U S -S 9nU RU5 SUl XR4$) aConverts a non-SparseEncoder model into a SparseEncoder by appending a SparseAutoEncoder. If ``model_type`` is ``"SentenceTransformer"``, loads the SentenceTransformer modules and appends a SparseAutoEncoder on top. Otherwise, falls back to :meth:`_load_default_modules`. SentenceTransformer)r0r,r.r-r/r1r%r2rzWSentenceTransformer model found, appending SparseAutoEncoder on top to form a CSR modelNrzCannot determine the embedding dimension from the loaded modules. At least one module must have a `get_embedding_dimension` method.rr )rrgr_load_config_modules module_kwargsrlr>rhasattrrr<rappend_model_card_text)rAr8r0r,r.r-r/r1r%r2 model_typerr(rrBrs rD_load_converted_modules%SparseEncoder._load_converted_moduless$ . .--")!"3!1)!1+.  !2 0  A-@L,>B@ HmH0@0FBHB=B]-@bB  mn&*&?&? %/-%-''@ ' ##w~~'( w'Fv899#;;= (  T   :~Ao/   s $****rFc[U[R5(d [S5eURS;a[ SURS35eURS:XaUR S5nURupUS:XdUS:XaSSS .$UR5nUR5nUSS US S - n[R"UR55R5nSXR- - nUUS .$) a Calculate sparsity statistics for the given embeddings, including the mean number of active (non-zero) dimensions and the mean sparsity ratio. For a single embedding (1D), the values are for that embedding directly. For a batch of embeddings (2D), they are averaged across the batch. Args: embeddings (torch.Tensor): The embeddings to analyze. Must be a 1D or 2D tensor. Returns: dict[str, float]: Dictionary with ``"active_dims"`` (mean active dimensions) and ``"sparsity_ratio"`` (mean sparsity ratio). Example: :: from sentence_transformers import SparseEncoder model = SparseEncoder("naver/splade-cocondenser-ensembledistil") embeddings = model.encode(["The weather is so nice!", "It's so sunny outside."]) stats = model.sparsity(embeddings) print(stats) # => {'active_dims': 44.0, 'sparsity_ratio': 0.9985584020614624} z!Embeddings must be a torch.Tensor)rrz Expected a 1D or 2D tensor, got D.rrgg?) active_dimssparsity_ratioN) r?r'r TypeErrorndimr< unsqueezeshape to_sparse_csr crow_indicesrfloatitem)rnum_rowsnum_colsr0non_zero_per_rowmean_active_dimsmean_sparsity_ratios rDsparsitySparseEncoder.sparsitys 6*ell33?@ @ ??& (? ?PPRST T ??a #--a0J'-- q=HM""%   --/ !..0 '+l3B.?? ::&6&<&<&>?DDF!%5%@A,1  rFc>[TU]$)aZ 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 SparseEncoder model = SparseEncoder("naver/splade-cocondenser-ensembledistil") print(model.max_seq_length) # => 512 )r:max_seq_lengthrs rDr;SparseEncoder.max_seq_lengths"w%%rFcXSlg)zc Property to set the maximal input sequence length for the model. Longer inputs will be truncated. rN)r;rs rDr;r<'s "'QrFc>[TU]$)a Property to get the underlying transformers PreTrainedModel instance, if it exists. Note that it's possible for a model to have multiple underlying transformers models, but this property will return the first one it finds in the module hierarchy. Returns: PreTrainedModel or None: The underlying transformers model or None if not found. Example: :: from sentence_transformers import SparseEncoder model = SparseEncoder("naver/splade-v3") # You can now access the underlying transformers model transformers_model = model.transformers_model print(type(transformers_model)) # => )r:transformers_modelrs rDr? SparseEncoder.transformers_model/s,w))rFcxURR5Hn[U[5(dMUs $ g)zVReturns the SpladePooling module if present, or None. Only searches top-level modules.N)r=r>r?r)rArBs rD_get_splade_pooling!SparseEncoder._get_splade_poolingGs0mm**,F&-00 -rFclUR5nUb UR$[RS5 g)a; Returns the chunk size of the SpladePooling module, if present. This chunk size is along the sequence length dimension (i.e., number of tokens per chunk). If None, processes the entire sequence at once. Using smaller chunks reduces memory usage but may lower training and inference speed. Default is None. This property is only meaningful for SPLADE-architecture models. For CSR-architecture models (Transformer + Pooling + SparseAutoEncoder), it returns None. Returns: int or None: The chunk size, or None if SpladePooling is not found or chunk_size is not set. Nz6SpladePooling module not found. Cannot get chunk_size.rBrSrgwarning)rAsplade_poolings rDsplade_pooling_chunk_size'SparseEncoder.splade_pooling_chunk_sizeNs4113  %!,, ,OPrFcbUR5nUbXlg[RS5 g)z> Sets the chunk size of the SpladePooling module, if present. Nz6SpladePooling module not found. Cannot set chunk_size.rE)rArrGs rDrHrIcs+ 113  %(- % NNS TrFc>UR(dUR5nUR(dUR5nURS:wa[SURS35eURSURS:wa,[SURSSURSS35eURS:XaX-nOSURS:Xa*[ R "UVs/sHo0U-PM sn5nO[S URS35eUR5nUR5S :n[ R"UR5S S 2U4UR5UUR5URS 9nU$s snf) a/ Compute the intersection of two sparse embeddings via element-wise multiplication. For each dimension, the result retains the minimum contribution from both embeddings, keeping only dimensions where both inputs are positive (i.e., shared active dimensions). This is useful for token-level matching and interpretability when combined with :meth:`decode`. Args: embeddings_1 (torch.Tensor): First embedding tensor of shape ``(vocab_size,)``. embeddings_2 (torch.Tensor): Second embedding tensor of shape ``(vocab_size,)`` or ``(batch_size, vocab_size)``. Returns: torch.Tensor: Sparse intersection tensor with the same shape as ``embeddings_2``. Example: :: from sentence_transformers import SparseEncoder model = SparseEncoder("naver/splade-cocondenser-ensembledistil") query_emb = model.encode_query("What is AI?") doc_emb = model.encode_document("Artificial intelligence is a branch of computer science.") shared = model.intersection(query_emb, doc_emb) print(model.decode(shared, top_k=5)) rz-Expected 1D tensor for embeddings_1, but got z shape.r*z+Vocab dimension mismatch: embeddings_1 has z, embeddings_2 has r9rz3Expected 1D or 2D tensor for embeddings_2, but got rN)sizer)) is_sparserr,r<r.r'rcoalescer>sparse_coo_tensorindicesrLr)) embeddings_1 embeddings_2 intersection embeddingr(s rDrSSparseEncoder.intersectionns>%%'113L%%'113L    !L\M_M_L``ghi i   b !\%7%7%; ;=l>P>PQS>T=UV$$0$6$6r$:#;1>     !'6L   ! # ;;R^'_R^Yy(@R^'_`LRS_SeSeRffmno o$,,. "))+a/ ..  "1k> 2    !+ .""$&&  (`s1Fc UbUS::a[SUS35e[U[R5(d[ S[ U535eUR S:HnU(aURS5nO)UR S:wa[SUR S35eUR(dUR5nUR5nUR5nUR5nUR5S:Xa8[URS55Vs/sHn/PM nnU(aUS$U$USUSp[R "XRS5S 9R#5n /nSn U Hn U S:XaUR%/5 MX[X-n XX-nUb ['X,5OU nX:a![R("X5unnUUnUn O[R*"U S S 9nU Un UUnUR,R/UR#55nUR%[1[3UU R#5555 X- n M U(aUS$U$s snf) a Decode a sparse embedding into (token, weight) pairs sorted by descending weight. Args: embeddings (torch.Tensor): Sparse embedding tensor of shape ``(vocab_size,)`` for a single embedding or ``(batch_size, vocab_size)`` for a batch. top_k (int, optional): Maximum number of top-weighted tokens to return per sample. If ``None``, all non-zero tokens are returned. Must be positive. Defaults to ``None``. Returns: list[tuple[str, float]]: If the input is 1D, a list of ``(token, weight)`` tuples. list[list[tuple[str, float]]]: If the input is 2D, a list (one per sample) of lists of ``(token, weight)`` tuples. rz&top_k must be a positive integer, got r9zExpected torch.Tensor, got rrz#Input tensor must be 1D or 2D, got r') minlengthT) descending)r<r?r'r r+rr,r-rMrrNrPr>numelrrLbincountror!rtopkry tokenizerconvert_ids_to_tokensrlzip)rArtop_kwas_1drPr>rresultssample_indices token_indices sample_counts start_idxcount sample_values sample_tokens effective_k top_valuestop_idx sorted_idx token_strss rDdecodeSparseEncoder.decodesP"  !EeWANO O*ell339$z:J9KLM MA% #--a0J __ !B:??BSSUVW W###--/J((* $$&""$ <<>Q BG XYHZB[5\B[QbB[G5\!'71: 4W 4(/ GAJ ~QRAST[[]  "Ezr""y/@AM)i6GHM/4/@#e+eK"&+jj&L# G -g 6 * "]]=TJ -j 9 -j 9 ==m>R>R>TUJ NN4J 0D0D0F GH I  I+#.$wqz00?6]s! I+c 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/sparse_encoder/SparseEncoder.html#sentence_transformers.sparse_encoder.SparseEncoder.push_to_hub).* )rCrr get_backend)rArepo_id class_namer4s rD_push_to_hub_usage_tip$SparseEncoder._push_to_hub_usage_tipsZ^^,, ""$#$.,/    YY rF)r"rrrr6rr5r)$r8rr(zlist[nn.Module] | Noner)rr*zdict[str, str] | Noner+rr,rr-boolr.rr/rvr0bool | str | Noner1dict[str, Any] | Noner%rxr2rxr3z!SparseEncoderModelCardData | Noner4z$Literal['torch', 'onnx', 'openvino']r5zstr | SimilarityFunction | Noner6 int | NonereturnNone) NN NTTFNNNN)rGzlist[TextInput] | TextInputrKrrLrrMintrN bool | NonerOrvrPrvrQrvr)4str | torch.device | list[str | torch.device] | Noner6ryrR9dict[Literal['input', 'output', 'processes'], Any] | NonerSryrXrrzlist[Tensor] | Tensor)rzdict[str, Any])rrrzr{)rzz2Literal['cosine', 'dot', 'euclidean', 'manhattan'])rzNLiteral['cosine', 'dot', 'euclidean', 'manhattan'] | SimilarityFunction | Nonerzr{)rrvrzr{)rr rr rzr )rnpt.NDArray[np.float32]rrrzr )rzzVCallable[[Tensor | npt.NDArray[np.float32], Tensor | npt.NDArray[np.float32]], Tensor])TNNN) rGzlist[TextInput]rNr~rRrr)rrSryrzr) rstrrrrrrrrzr{)rzry)NFFNNN)r8rr0rwr,rr.rr-rvr/rvr1rxr%rxr2rxrz&tuple[list[nn.Module], dict[str, Any]])NFFNNNN)r8rr0rwr,rr.rr-rvr/rvr1rxr%rxr2rxr#rrzr)r torch.Tensorrzzdict[str, float])rzr})rr}rzr{)rzzPreTrainedModel | None)rzzSpladePooling | None)rryrzr{)rQrrRrrzr )rrr_ryrzz7list[tuple[str, float]] | list[list[tuple[str, float]]])rrrrzr),rr __module__ __qualname____firstlineno____doc__rmodel_card_data_classr __annotations__r# _model_card_model_id_placeholderrr;rYr_rWrrpropertyr5setterrrrrrt staticmethodrrr FutureWarningrrr$r8r;r?rBrHrSrnrt__static_attributes__ __classcell__)rCs@rDrr#s`_B73C$jC8<$.O+O'@$(:;*.4+/!)-*.#'"'#!&#'.226/3=A8?>B&*)4&4( 4  4 ' 4(4!4 444!4,404-4 ;!4"6#4&<'4($)4* +44<4l*#'!)-"&)-!GK&*JN!%F +F  F  F  F ' F  F #'F F EF $F HF F F  F +F P*#'!)-"&)-!GK&*JN!%I +I  I  I  I ' I  I #'I I EI $I HI I I  I +I V*#'!)-"&)-!GK&*JN!%M+M M M  M ' M M#'MMEM$MHMMM M+M^ S ((  \] \  \ \ QQ ss ) ) VZZ 2AX $) _$)$)R*.JNGK!% >3>3'>3H >3 E >3  >3 >3@#0?DUZ 22f. . $"'!&.226/3WW!W! W  W  WW,W0W-W 0W| $"'!&.226/3!%J+J+!J+! J+  J+  J+J+,J+0J+-J+J+ 0J+X7 7 r&&$''**.(%%U&U>">"> >>B=AF1&F1/9F1 @F1PrFr)8 __future__rrrrrcollections.abcrmultiprocessingrtypingrrrnumpyrm numpy.typingnptr'r r tqdmr transformersr r transformers.modeling_utilsrtransformers.utilstransformers_loggingtyping_extensionsrsentence_transformers.baser)sentence_transformers.base.modality_typesr"sentence_transformers.base.modulesr2sentence_transformers.sentence_transformer.modulesr/sentence_transformers.sparse_encoder.model_cardr,sentence_transformers.sparse_encoder.modulesrrsentence_transformers.utilrr%sentence_transformers.util.decoratorsr%sentence_transformers.util.similarityr get_loggerrrrgrrUrFrDrsv" $!)) 57>(0?:FVYNCD  ( ( 2pIprF