rhLddlmZddlZddlZddlmZ ddlmZddl m Z m Z ddl mZddlmZddlmZdd lmZmZej,eZGd d eZeZy#e$r ddl mZYOwxYw) ) annotationsN)Path)Self)Tensornn)logging) InputModule)Module)import_from_string load_dir_pathc eZdZUdhZddgZded<dZ d dfd Ze d ddZ ddd Z dd Z ddd Z ddd Z e d dd ZedZeddZej$ddZxZS)Routertask default_routeallow_empty_keyz list[str] config_keyszrouter_config.jsonc t||t|dk(r td|,||vr(td|dt |j t j|jDcic]\}}|t j|c}}|_ |r$|"tt|j }||_ ||_ycc}}w)a This model allows to create asymmetric SentenceTransformer models that apply different modules depending on the specified route, such as "query" or "document". Especially useful for models that have different encoders for queries and documents. Notably, the ``task`` argument of ``model.encode`` can be used to specify which route to use, and ``model.encode_query`` and ``model.encode_document`` are shorthands for using ``task="query"`` and ``task="document"``, respectively. These methods also optionally apply ``prompts`` specific to queries or documents. .. note:: When training models with the :class:`~sentence_transformers.models.Router` module, you must use the ``router_mapping`` argument in the :class:`~sentence_transformers.training_args.SentenceTransformerTrainingArguments` or :class:`~sentence_transformers.sparse_encoder.training_args.SparseEncoderTrainingArguments` to map the training dataset columns to the correct route ("query" or "document"). For example, if your training dataset(s) have ``["question", "positive", "negative"]`` columns, then you can use the following mapping:: args = SparseEncoderTrainingArguments( ..., router_mapping={ "question": "query", "positive": "document", "negative": "document", } ) Additionally, it is common to use a different learning rate for the different routes. For this, you should use the ``learning_rate_mapping`` argument in the :class:`~sentence_transformers.training_args.SentenceTransformerTrainingArguments` or :class:`~sentence_transformers.sparse_encoder.training_args.SparseEncoderTrainingArguments` to map parameter patterns to their learning rates. For example, if you want to use a learning rate of ``1e-3`` for an SparseStaticEmbedding module and ``2e-5`` for the rest of the model, you can do this:: args = SparseEncoderTrainingArguments( ..., learning_rate=2e-5, learning_rate_mapping={ r"SparseStaticEmbedding\.*": 1e-3, } ) In the below examples, the ``Router`` model is used to create asymmetric models with different encoders for queries and documents. In these examples, the "query" route is efficient (e.g., using SparseStaticEmbedding), while the "document" route uses a more complex model (e.g. a Transformers module). This allows for efficient query encoding while still using a powerful document encoder, but the combinations are not limited to this. Example: :: from sentence_transformers import SentenceTransformer from sentence_transformers.models import Router, Normalize # Use a regular SentenceTransformer for the document embeddings, and a static embedding model for the query embeddings document_embedder = SentenceTransformer("mixedbread-ai/mxbai-embed-large-v1") query_embedder = SentenceTransformer("sentence-transformers/static-retrieval-mrl-en-v1") router = Router.for_query_document( query_modules=list(query_embedder.children()), document_modules=list(document_embedder.children()), ) normalize = Normalize() # Create an asymmetric model with different encoders for queries and documents model = SentenceTransformer( modules=[router, normalize], ) # ... requires more training to align the vector spaces # Use the query & document routes query_embedding = model.encode_query("What is the capital of France?") document_embedding = model.encode_document("Paris is the capital of France.") :: from sentence_transformers.models import Router from sentence_transformers.sparse_encoder import SparseEncoder from sentence_transformers.sparse_encoder.models import MLMTransformer, SparseStaticEmbedding, SpladePooling # Load an asymmetric model with different encoders for queries and documents doc_encoder = MLMTransformer("opensearch-project/opensearch-neural-sparse-encoding-doc-v3-distill") router = Router.for_query_document( query_modules=[ SparseStaticEmbedding.from_json( "opensearch-project/opensearch-neural-sparse-encoding-doc-v3-distill", tokenizer=doc_encoder.tokenizer, frozen=True, ), ], document_modules=[ doc_encoder, SpladePooling(pooling_strategy="max", activation_function="log1p_relu"), ], ) model = SparseEncoder(modules=[router], similarity_fn_name="dot") query = "What's the weather in ny now?" document = "Currently New York is rainy." query_embed = model.encode_query(query) document_embed = model.encode_document(document) sim = model.similarity(query_embed, document_embed) print(f"Similarity: {sim}") # Visualize top tokens for each text top_k = 10 print(f"Top tokens {top_k} for each text:") decoded_query = model.decode(query_embed, top_k=top_k) decoded_document = model.decode(document_embed) for i in range(min(top_k, len(decoded_query))): query_token, query_score = decoded_query[i] doc_score = next((score for token, score in decoded_document if token == query_token), 0) if doc_score != 0: print(f"Token: {query_token}, Query score: {query_score:.4f}, Document score: {doc_score:.4f}") ''' Similarity: tensor([[11.1105]], device='cuda:0') Top tokens 10 for each text: Token: ny, Query score: 5.7729, Document score: 0.8049 Token: weather, Query score: 4.5684, Document score: 0.9710 Token: now, Query score: 3.5895, Document score: 0.4720 Token: ?, Query score: 3.3313, Document score: 0.0286 Token: what, Query score: 2.7699, Document score: 0.0787 Token: in, Query score: 0.4989, Document score: 0.0417 ''' Note: These models are not necessarily stronger than non-asymmetric models. Rudimentary experiments indicate that non-Router models perform better in many cases. Args: sub_modules: Mapping of route keys to lists of modules. Each key corresponds to a specific task type, often "query" or "document", and the list contains the modules to be applied for that task type. default_route: The default route to use if no task type is specified. If None, an exception will be thrown if no task type is specified. If ``allow_empty_key`` is True, the first key in sub_modules will be used as the default route. Defaults to None. allow_empty_key: If True, allows the default route to be set to the first key in `sub_modules` if ``default_route`` is None. Defaults to True. Nrz&The routes dictionary cannot be empty.zDefault route 'z' not found in route keys: )super__init__len ValueErrorlistkeysr ModuleDictitems Sequential sub_modulesnextiterrr)selfrrr route_namemodules __class__s v/var/www/html/ai-insurance-compliance-backend/venv/lib/python3.12/site-packages/sentence_transformers/models/Router.pyrzRouter.__init__s`   #k"2a"7EF F  $k)I}o=XY]^i^n^n^pYqXrst t==LWL]L]L_ `5HZZ0 0 `  }4 k&6&6&8!9:M*. as;C c&|||d|xsd|S)a Creates a Router model specifically for query and document modules, allowing convenient usage via `model.encode_query` and `model.encode_document`. Args: query_modules: List of modules to be applied for the "query" task type. document_modules: List of modules to be applied for the "document" task type. default_route: The default route to use if no task type is specified. If None, an exception will be thrown if no task type is specified. If ``allow_empty_key`` is True, the first key in sub_modules will be used as the default route. Defaults to None. allow_empty_key: If True, allows the default route to be set to the first key in `sub_modules` if ``default_route`` is None. Defaults to True. Returns: Router: An instance of the Router model with the specified query and document modules. )querydocumentr')rrr)cls query_modulesdocument_modulesrrs r$for_query_documentzRouter.for_query_documents%0"/=MN'5:+  c ||jd|j}|"|jr tdtd||jvr2td|dt |jj ||d<|j|D]H}|jDcic]"\}}t|dr||jvr||$}}}||fi|}J|Scc}}w)NrvYou must provide a `router_mapping` argument on the training arguments, or set a default route in the `Router` module.kYou must provide a `task` argument when calling this method, or set a default route in the `Router` module.No route found for task type ''. Available routes: forward_kwargs) getrtrainingrrrrrhasattrr3)r featuresrkwargsmodulekeyvalue module_kwargss r$forwardzRouter.forwards <<<(:(:;D <}} E !E t'' '06KDQUQaQaQfQfQhLiKjk v&&t, 9F#),,.C6#34@U@U9UU M h8-8H  9 s-'C$c|jjD]2}t|D]"}t|ds|j ccS4y)N get_sentence_embedding_dimension)rvaluesreversedr6r?)r rr9s r$r?z'Router.get_sentence_embedding_dimensionsW++224 EK";/ E6#EF!BBDD E Er-c Vi}i}i}|jjD]\}}g||<t|D]k\} } |d| dt| j} | || <t| j dt| j|| <||j | m|jD][\} } tjj|t| } tj| d | j| fd|i|]ttjj||jdd5} t!j"|||j%d | d dddy#t$r| j| YwxYw#1swYyxYw) N_.T)exist_oksafe_serializationwutf8)encoding)types structure parameters)indent)rr enumeratetype__name__ __module__appendospathjoinstrmakedirssave TypeErroropenconfig_file_namejsondumpget_config_dict)r output_pathrFr8 model_lookup model_typesmodel_structurenamemodels module_idxmodelmodel_id model_pathfOuts r$rYz Router.saves   ,,224 7LD&$&OD !%.v%6 7! E"V1ZL$u+2F2F1GH). X&+/;+A+A*B!DKDXDXCY(Z H%%,,X6  7 7 ,113 'OHek3x=AJ KK T 2 ' :W:LWPVW  '"'',,{D,A,ABCRX Y ]a II(!0"&"6"6"8      ' :& '  s>E? +F?FFF(c  t|dtrO|;td|D}t|dkDr t d|j }|Dcgc]}|| }}| |j }|"|jr t dt d||jvr2t d|dt|jj|j|d}|j|fi|}||d <|Scc}w) z-Tokenizes a text and maps tokens to token-idsrc3JK|]}|jD]}|ywN)r).0textr:s r$ z"Router.tokenize..$s"IDTYY[IcCICIs!#zYou cannot pass a list of dictionaries with different task types. Please ensure all dictionaries have the same task type key, or pass a single `task` argument.r/r0r1r2r) isinstancedictsetrrpoprr5rrrtokenize)r textsrr8tasksro input_module tokenizeds r$rvzRouter.tokenizes4 eAh %|IEIIu:>$xyy{-22DT$Z2E2 <%%D <}} E !E t'' '06KDQUQaQaQfQfQhLiKjk ''-a0 )L))%:6:  &/3s Dc L||||d}|jd ||d|} | s|jd |d|d|} i} | djD]E\} } t| } | j|fdt || j i||}|| | <Gi}| djD](\}}g||<|D]} ||j| | *||fi| d}|S#t $r:td |t || j d|}| j|}YwxYw) N)token cache_folderrevisionlocal_files_only)model_name_or_path subfolderz config.json)rconfig_filenamerrJrrKrLr() load_configrr loadras_posixrZr rS)r)rrr|r}r~rr8 hub_kwargsconfigr"rh model_type module_classr9 local_pathrckey_name models_listrgs r$rz Router.loadFs( 0  !j4FR[j_ij$S__#5}`imwF$*7O$9$9$; ' Hj#5j#AL 7***&26y(2K2T2T2VZdhn!'GH  '%+K%8%>%>%@ D !Hk(*OH %' D)001BC D D Ot}|jjD]2}|d}|s t|ds|j |j 4|syt |dk(r|jStjd|dt|S)Nrmax_seq_lengthrqz$Different max_seq_lengths detected: z. Using the maximum value.) rtrr@r6addrrrulogger warning_oncemax)r max_seq_lengthsr"rys r$rzRouter.max_seq_length}s%''..0 AG(/ L7<1AB##L$?$?@ A   !Q &"&&( (   "FFWWq r s' 'r-cg}|jjD])\}}|s t|dds|j|+t |dk(rt j dy|D]}|j|d}||_y)Nrrz2No modules have a max_seq_length attribute to set.)rrr6rSrrwarningr)r r;has_max_seq_length_keysr:rerys r$rzRouter.max_seq_lengths#%++113 4KC'&)-=>'..s3 4 & '1 , NNO P * 0C(,(8(8(=a(@L*/L ' 0r-)NT)rzdict[str, list[Module]]r str | NonerboolreturnNone) r* list[Module]r+rrrrrrrrm)r7dict[str, Tensor]rrrr)rint)T)r`rWrFr)rwz!list[str] | list[tuple[str, str]]rr)NNNF)rrWrrWr|zbool | str | Noner}rr~rrrrr)rr)rQrR __qualname__r3r__annotations__r\r classmethodr,r=r?rYrvrpropertyrrsetter __classcell__)r#s@r$rrs`XN-/@AKA+os^/2^/CM^/gk^/ ^/@ %) $  # ' "       :<B%N#'#'#!&+++! + ! +  ++ ++Z((" 0 0r-r) __future__rr]rTpathlibrtypingr ImportErrortyping_extensionstorchrrtransformers.utilsr(sentence_transformers.models.InputModuler #sentence_transformers.models.Moduler sentence_transformers.utilr r get_loggerrQrrAsymr(r-r$rsg" '&@6H   H %G0[G0V q '&'sA A,+A,