蘺h<dZddlmZddlmZmZmZmZddlZ ddl m Z ddl m Z ddlmZmZddlmZmZmZdd lmZdd lmZmZdd lmZdd lmZGd deeZGddeZ Gdde eZ!Gdde eZ"dS)z@A chain for comparing the output of two models using embeddings.)Enum)AnyDictListOptionalN)OpenAIEmbeddings) Embeddings)Fieldroot_validator)AsyncCallbackManagerForChainRunCallbackManagerForChainRun Callbacks)Chain)PairwiseStringEvaluatorStringEvaluatorRUN_KEYcosine_similarityc&eZdZdZdZdZdZdZdZdS)EmbeddingDistancea Embedding Distance Metric. Attributes: COSINE: Cosine distance metric. EUCLIDEAN: Euclidean distance metric. MANHATTAN: Manhattan distance metric. CHEBYSHEV: Chebyshev distance metric. HAMMING: Hamming distance metric. cosine euclidean manhattan chebyshevhammingN) __name__ __module__ __qualname____doc__COSINE EUCLIDEAN MANHATTAN CHEBYSHEVHAMMINGt/var/www/html/services/rag-service/venv/lib/python3.11/site-packages/langchain/evaluation/embedding_distance/base.pyrrs3FIIIGGGr'rc|eZdZUdZeeZeed<ee j Z e ed<e dde eefd e eeffd ZGd d Zed eefd Zded efdZde d efdZedejdejd ejfdZedejdejd ejfdZedejdejd ejfdZedejdejd ejfdZedejdejd ejfdZ dejd e!fdZ"dS)_EmbeddingDistanceChainMixina0Shared functionality for embedding distance evaluators. Attributes: embeddings (Embeddings): The embedding objects to vectorize the outputs. distance_metric (EmbeddingDistance): The distance metric to use for comparing the embeddings. )default_factory embeddings)defaultdistance_metricF)prevaluesreturnc|d}t|tr# ddl}n#t$rt dwxYw|S)zValidate that the TikTok library is installed. Args: values (Dict[str, Any]): The values to validate. Returns: Dict[str, Any]: The validated values. r,rNzThe tiktoken library is required to use the default OpenAI embeddings with embedding distance evaluators. Please either manually select a different Embeddings object or install tiktoken using `pip install tiktoken`.)get isinstancertiktoken ImportError)clsr0r,r5s r(_validate_tiktoken_installedz9_EmbeddingDistanceChainMixin._validate_tiktoken_installed3srZZ -- j"2 3 3     !I  s 1A c"eZdZUdZdZeed<dS)#_EmbeddingDistanceChainMixin.Configz$Permit embeddings to go unvalidated.Tarbitrary_types_allowedN)rrrr r;bool__annotations__r&r'r(Configr:Js)22(,,,,,,r'r>cdgS)zgReturn the output keys of the chain. Returns: List[str]: The output keys. scorer&selfs r( output_keysz(_EmbeddingDistanceChainMixin.output_keysOs yr'resultcVd|di}t|vr|t|t<|S)Nr@r)rBrDparseds r(_prepare_outputz,_EmbeddingDistanceChainMixin._prepare_outputXs-6'?+ f  $WoF7O r'metricc tj|jtj|jtj|jtj|jtj |j i}||vr||Std|)zGet the metric function for the given metric name. Args: metric (EmbeddingDistance): The metric name. Returns: Any: The metric function. zInvalid metric: ) rr!_cosine_distancer"_euclidean_distancer#_manhattan_distancer$_chebyshev_distancer%_hamming_distance ValueError)rBrHmetricss r( _get_metricz(_EmbeddingDistanceChainMixin._get_metric^sp  $d&;  ')A  ')A  ')A  %t'=   W  6? "88899 9r'abc(dt||z S)zCompute the cosine distance between two vectors. Args: a (np.ndarray): The first vector. b (np.ndarray): The second vector. Returns: np.ndarray: The cosine distance. g?rrRrSs r(rJz-_EmbeddingDistanceChainMixin._cosine_distancess&q!,,,,r'cFtj||z S)zCompute the Euclidean distance between two vectors. Args: a (np.ndarray): The first vector. b (np.ndarray): The second vector. Returns: np.floating: The Euclidean distance. )nplinalgnormrUs r(rKz0_EmbeddingDistanceChainMixin._euclidean_distancesy~~a!e$$$r'cTtjtj||z S)zCompute the Manhattan distance between two vectors. Args: a (np.ndarray): The first vector. b (np.ndarray): The second vector. Returns: np.floating: The Manhattan distance. )rWsumabsrUs r(rLz0_EmbeddingDistanceChainMixin._manhattan_distance vbfQUmm$$$r'cTtjtj||z S)zCompute the Chebyshev distance between two vectors. Args: a (np.ndarray): The first vector. b (np.ndarray): The second vector. Returns: np.floating: The Chebyshev distance. )rWmaxr\rUs r(rMz0_EmbeddingDistanceChainMixin._chebyshev_distancer]r'c2tj||kS)zCompute the Hamming distance between two vectors. Args: a (np.ndarray): The first vector. b (np.ndarray): The second vector. Returns: np.floating: The Hamming distance. )rWmeanrUs r(rNz._EmbeddingDistanceChainMixin._hamming_distanceswqAvr'vectorsc||j}||ddd|ddd}|S)zCompute the score based on the distance metric. Args: vectors (np.ndarray): The input vectors. Returns: float: The computed score. r)rQr.reshapeitem)rBrbrHr@s r(_compute_scorez+_EmbeddingDistanceChainMixin._compute_scoresd!!$"677wqz))!R00'!*2D2DQ2K2KLLQQSS r'N)#rrrr r rr,r r=rr!r.r rstrrr8r>propertyrrCdictrGrQ staticmethodrWndarrayrJfloatingrKrLrMrNfloatrhr&r'r(r*r*'s#U3CDDDJ DDD).7H7O)P)P)PO&PPP^$sCx.T#s(^,-------- T#YXdt :"3:::::* -BJ -2: -"* - - -\ - %rz %bj %R[ % % %\ % %rz %bj %R[ % % %\ % %rz %bj %R[ % % %\ % RZ BJ 2;   \  bj U      r'r*ceZdZdZedefdZedefdZede efdZ dde ee fde ede ee ffd Z dde ee fde ede ee ffd Zddddd d d ede edede e ede e ee fdede defdZddddd d d ede edede e ede e ee fdede defdZdS)EmbeddingDistanceEvalChaina"Use embedding distances to score semantic difference between a prediction and reference. Examples: >>> chain = EmbeddingDistanceEvalChain() >>> result = chain.evaluate_strings(prediction="Hello", reference="Hi") >>> print(result) {'score': 0.5} r1cdS)zReturn whether the chain requires a reference. Returns: bool: True if a reference is required, False otherwise. Tr&rAs r(requires_referencez-EmbeddingDistanceEvalChain.requires_references tr'c"d|jjdS)N embedding_ _distancer.valuerAs r(evaluation_namez*EmbeddingDistanceEvalChain.evaluation_namesAD06AAAAr'c ddgS)eReturn the input keys of the chain. Returns: List[str]: The input keys. prediction referencer&rAs r( input_keysz%EmbeddingDistanceEvalChain.input_keyssk**r'Ninputs run_managerctj|j|d|dg}||}d|iS)a0Compute the score for a prediction and reference. Args: inputs (Dict[str, Any]): The input data. run_manager (Optional[CallbackManagerForChainRun], optional): The callback manager. Returns: Dict[str, Any]: The computed score. r|r}r@rWarrayr,embed_documentsrhrBrrrbr@s r(_callz EmbeddingDistanceEvalChain._callsW( O + +VL-A6+CV,W X X  ##G,,r'cK|j|d|dgd{V}tj|}||}d|iS)a:Asynchronously compute the score for a prediction and reference. Args: inputs (Dict[str, Any]): The input data. run_manager (AsyncCallbackManagerForChainRun, optional): The callback manager. Returns: Dict[str, Any]: The computed score. r|r}Nr@r,aembed_documentsrWrrhrBrrembeddedrbr@s r(_acallz!EmbeddingDistanceEvalChain._acalls~99 L !6+#6 7        (8$$##G,,r'F)r} callbackstagsmetadatainclude_run_infor|r}rrrrkwargsc R|||d||||}||S)aEvaluate the embedding distance between a prediction and reference. Args: prediction (str): The output string from the first model. reference (str): The reference string (required) callbacks (Callbacks, optional): The callbacks to use. **kwargs (Any): Additional keyword arguments. Returns: dict: A dictionary containing: - score: The embedding distance between the two predictions. r|r}rrrrrrG rBr|r}rrrrrrDs r(_evaluate_stringsz,EmbeddingDistanceEvalChain._evaluate_stringssG2",9EE-    ##F+++r'cvK|||d||||d{V}||S)aAsynchronously evaluate the embedding distance between a prediction and reference. Args: prediction (str): The output string from the first model. reference (str): The output string from the second model. callbacks (Callbacks, optional): The callbacks to use. **kwargs (Any): Additional keyword arguments. Returns: dict: A dictionary containing: - score: The embedding distance between the two predictions. rrNacallrGrs r(_aevaluate_stringsz-EmbeddingDistanceEvalChain._aevaluate_strings0sk2zz",9EE- "        ##F+++r'N)rrrr rjr<rsriryrr~rrrr rr rrrkrrr&r'r(rqrqsrDXBBBBXB+DI+++X+=A  S#X 89  c3h     0BF  S#X =>  c3h     4$(#$(-1!& , , , ,C= ,  , tCy! ,4S>* , , ,  , , , ,L$(#$(-1!& , , , ,C= ,  , tCy! ,4S>* , , ,  , , , , , ,r'rqceZdZdZedeefdZedefdZ dde ee fde e de ee ffdZ dde ee fde ede ee ffd Zdddd d d ed edede eede e ee fdede defdZdddd d d ed edede eede e ee fdede defdZdS)"PairwiseEmbeddingDistanceEvalChainaUse embedding distances to score semantic difference between two predictions. Examples: >>> chain = PairwiseEmbeddingDistanceEvalChain() >>> result = chain.evaluate_string_pairs(prediction="Hello", prediction_b="Hi") >>> print(result) {'score': 0.5} r1c ddgS)r{r| prediction_br&rAs r(r~z-PairwiseEmbeddingDistanceEvalChain.input_keys_sn--r'c"d|jjdS)Npairwise_embedding_rvrwrAs r(ryz2PairwiseEmbeddingDistanceEvalChain.evaluation_namehsJT%9%?JJJJr'Nrrctj|j|d|dg}||}d|iS)aCompute the score for two predictions. Args: inputs (Dict[str, Any]): The input data. run_manager (CallbackManagerForChainRun, optional): The callback manager. Returns: Dict[str, Any]: The computed score. r|rr@rrs r(rz(PairwiseEmbeddingDistanceEvalChain._callls\( O + + %vn'=>     ##G,,r'cK|j|d|dgd{V}tj|}||}d|iS)a/Asynchronously compute the score for two predictions. Args: inputs (Dict[str, Any]): The input data. run_manager (AsyncCallbackManagerForChainRun, optional): The callback manager. Returns: Dict[str, Any]: The computed score. r|rNr@rrs r(rz)PairwiseEmbeddingDistanceEvalChain._acalls~99 L !6.#9 :        (8$$##G,,r'F)rrrrr|rrrrrrc R|||d||||}||S)aEvaluate the embedding distance between two predictions. Args: prediction (str): The output string from the first model. prediction_b (str): The output string from the second model. callbacks (Callbacks, optional): The callbacks to use. tags (List[str], optional): Tags to apply to traces metadata (Dict[str, Any], optional): metadata to apply to **kwargs (Any): Additional keyword arguments. Returns: dict: A dictionary containing: - score: The embedding distance between the two predictions. r|rrr rBr|rrrrrrrDs r(_evaluate_string_pairsz9PairwiseEmbeddingDistanceEvalChain._evaluate_string_pairssG4",lKK-    ##F+++r'cvK|||d||||d{V}||S)aAsynchronously evaluate the embedding distance between two predictions. Args: prediction (str): The output string from the first model. prediction_b (str): The output string from the second model. callbacks (Callbacks, optional): The callbacks to use. tags (List[str], optional): Tags to apply to traces metadata (Dict[str, Any], optional): metadata to apply to traces **kwargs (Any): Additional keyword arguments. Returns: dict: A dictionary containing: - score: The embedding distance between the two predictions. rrNrrs r(_aevaluate_string_pairsz:PairwiseEmbeddingDistanceEvalChain._aevaluate_string_pairssk8zz",lKK- "        ##F+++r'r)rrrr rjrrir~ryrrrr rr rrr<rkrrr&r'r(rrSs=.DI...X.KKKKXK =A  S#X 89  c3h     4BF  S#X =>  c3h     6 $$(-1!&!,!,!,!, !,  !, tCy! !,4S>*!,!,!, !,!,!,!,P $$(-1!&#,#,#,#, #,  #, tCy! #,4S>*#,#,#, #,#,#,#,#,#,r'r)#r enumrtypingrrrrnumpyrW%langchain_community.embeddings.openairlangchain_core.embeddingsr langchain_core.pydantic_v1r r langchain.callbacks.managerr r rlangchain.chains.baserlangchain.evaluation.schemarrlangchain.schemarlangchain.utils.mathrrirr*rqrr&r'r(rsFF,,,,,,,,,,,,BBBBBB000000<<<<<<<< ('''''PPPPPPPP$$$$$$222222T$XXXXX5XXXvN,N,N,N,N,!=N,N,N,bL,L,L,L,L, "9L,L,L,L,L,r'