A'hIvdZddlZddlZddlmZddlmZddlmZm Z ddl m Z m Z m Z ddlmZddlmZdd lmZmZdd lmZdd lmZmZdd lmZd efdZej:eZej@dd e!fdZ"d efdZ#Gdde$eZ%GddeZ&Gdde&eZ'Gdde&eZ(y)z@A chain for comparing the output of two models using embeddings.N)Enum)util)AnyOptional)AsyncCallbackManagerForChainRunCallbackManagerForChainRun Callbacks) Embeddings)pre_init) ConfigDictField)Chain)PairwiseStringEvaluatorStringEvaluatorRUN_KEYreturncJ ddl}|S#t$r}td|d}~wwxYw)Nrz@Could not import numpy, please install with `pip install numpy`.)numpy ImportError)npes s/home/kushmeetdev/Regenta/Chatbot/venv/lib/python3.12/site-packages/langchain/evaluation/embedding_distance/base.py _import_numpyrs2  N  s " ")maxsizeclttjdrytj dy)NrTaNumPy not found in the current Python environment. langchain will use a pure Python implementation for embedding distance operations, which may significantly impact performance, especially for large datasets. For optimal speed and efficiency, consider installing NumPy: pip install numpyF)boolr find_specloggerwarningr _check_numpyr$%s, DNN7 #$ NN  r#c ddlm}|S#t$r) ddlm}n#t$r tdwxYwY|SwxYw)zaCreate an Embeddings object. Returns: Embeddings: The created Embeddings object. rOpenAIEmbeddingstCould not import OpenAIEmbeddings. Please install the OpenAIEmbeddings package using `pip install langchain-openai`.)langchain_openair'r%langchain_community.embeddings.openair&s r_embedding_factoryr+3sd 5       Q      s! A A5AAc$eZdZdZdZdZdZdZdZy)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 CHEBYSHEVHAMMINGr"r#rr-r-Js"FIIIGr#r-ceZdZUdZeeZeed<ee jZ e ed<e de eefde eeffdZed Zedeefd Zd e de fd Zde defdZedededefdZedededefdZedededefdZedededefdZedededefdZdedefdZy)_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_metricvaluesrcJ|jd}g} ddlm}|j| ddlm}|j||s t dt |t|r ddl}|S|S#t$rYNwxYw#t$rYEwxYw#t$r t dwxYw)zValidate that the TikTok library is installed. Args: values (Dict[str, Any]): The values to validate. Returns: Dict[str, Any]: The validated values. r?rr&r(NzThe 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`.) getr)r'appendrr* isinstancetupletiktoken)clsrBr?types_r'rHs r_validate_tiktoken_installedz9_EmbeddingDistanceChainMixin._validate_tiktoken_installedhsZZ -   9 MM* +   MM* +Q  j%- 0  v 9       !I s.A/A>'B / A;:A;> B  B  B"T)arbitrary_types_allowedcdgS)zgReturn the output keys of the chain. Returns: List[str]: The output keys. scorer"selfs r output_keysz(_EmbeddingDistanceChainMixin.output_keyss yr#resultcDd|di}t|vr|t|t<|S)NrNr)rPrRparseds r_prepare_outputz,_EmbeddingDistanceChainMixin._prepare_outputs*6'?+ f $WoF7O r#metricc 8tj|jtj|jtj |j tj|jtj|ji}||vr||Std|)zGet the metric function for the given metric name. Args: metric (EmbeddingDistance): The metric name. Returns: Any: The metric function. zInvalid metric: ) r-r7_cosine_distancer8_euclidean_distancer9_manhattan_distancer:_chebyshev_distancer;_hamming_distance ValueError)rPrVmetricss r _get_metricz(_EmbeddingDistanceChainMixin._get_metrics  $ $d&;&;  ' ')A)A  ' ')A)A  ' ')A)A  % %t'='=   W 6? "/x89 9r#abcX ddlm}d|||z S#t$r tdwxYw)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. r)cosine_similarityzThe cosine_similarity function is required to compute cosine distance. Please install the langchain-community package using `pip install langchain-community`.g?)langchain_community.utils.mathrcr)r`rarcs rrXz-_EmbeddingDistanceChainMixin._cosine_distancesB  H&q!,,,  6  s)ctr"ddl}|jj||z St dt ||DdzS)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. rNc38K|]\}}||z ||z zywNr".0xys r zC_EmbeddingDistanceChainMixin._euclidean_distance..s!;AAEa!e$;sg?)r$rlinalgnormsumzipr`rars rrYz0_EmbeddingDistanceChainMixin._euclidean_distances? > 99>>!a%( (;Q;;sBBr#ctr-t}|j|j||z Stdt ||DS)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. c3>K|]\}}t||z ywrgabsrhs rrlzC_EmbeddingDistanceChainMixin._manhattan_distance..4$!Q3q1u:4)r$rrorurprqs rrZz0_EmbeddingDistanceChainMixin._manhattan_distanceB >B66"&&Q-( (4#a)444r#ctr-t}|j|j||z Stdt ||DS)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. c3>K|]\}}t||z ywrgrtrhs rrlzC_EmbeddingDistanceChainMixin._chebyshev_distance..rvrw)r$rmaxrurprqs rr[z0_EmbeddingDistanceChainMixin._chebyshev_distancerxr#ctrt}|j||k7Stdt ||Dt |z S)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. c32K|]\}}||k7s dyw)rNr"rhs rrlzA_EmbeddingDistanceChainMixin._hamming_distance..s5Aa1f15s )r$rmeanrorplenrqs rr\z._EmbeddingDistanceChainMixin._hamming_distancesB >B7716? "5Q55A>>r#vectorscL|j|j}trft|t j rH||dj dd|dj ddj}t|S||d|d}t|S)zCompute the score based on the distance metric. Args: vectors (np.ndarray): The input vectors. Returns: float: The computed score. rr) r_rAr$rFrndarrayreshapeitemfloat)rPrrVrNs r_compute_scorez+_EmbeddingDistanceChainMixin._compute_scores!!$"6"67 >j-/2I2IJ71:--a4gaj6H6HB6OPUUWEU|71:wqz2EU|r#N) r3r4r5r6r r+r?r __annotations__r-r7rAr dictstrrrKr model_configpropertylistrQrUr_ staticmethodrXrYrZr[r\rrr"r#rr=r=\s#3EFJ F).7H7O7O)PO&P +$sCx.+T#s(^++Z $LT#Ydt :"3::*-C-C-C--(CsCsCsCC"5s5s5s55 5s5s5s55 ?S?S?S?? cer#r=cleZdZdZedefdZedefdZede efdZ dde ee fde ede ee ffd Z dde ee fde ede ee ffd Zddddd d d ede edede e ede e ee fdede de fdZddddd d d ede edede e ede e ee fdede de fdZy)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} rcy)zReturn whether the chain requires a reference. Returns: bool: True if a reference is required, False otherwise. Tr"rOs rrequires_referencez-EmbeddingDistanceEvalChain.requires_reference4sr#c6d|jjdS)N embedding_ _distancerAvaluerOs revaluation_namez*EmbeddingDistanceEvalChain.evaluation_name=sD00667yAAr#c ddgS)eReturn the input keys of the chain. Returns: List[str]: The input keys. prediction referencer"rOs r input_keysz%EmbeddingDistanceEvalChain.input_keysAsk**r#Ninputs run_managerc|jj|d|dg}trt}|j |}|j |}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. rrrNr?embed_documentsr$rarrayrrPrrrrrNs r_callz EmbeddingDistanceEvalChain._callJsa//11 L !6+#6 7  >Bhhw'G##G,r#cK|jj|d|dgd{}trt}|j |}|j |}d|iS7>w)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. rrNrNr?aembed_documentsr$rrrrs r_acallz!EmbeddingDistanceEvalChain._acallbsr88|${#    >Bhhw'G##G, 'A*A(?A*F)r callbackstagsmetadatainclude_run_inforrrrrrkwargsc D|||d||||}|j|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. rrrrrrrrU rPrrrrrrrrRs r_evaluate_stringsz,EmbeddingDistanceEvalChain._evaluate_strings}s52",9E-  ##F++r#crK|j||d||||d{}|j|S7w)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. rrNacallrUrs r_aevaluate_stringsz-EmbeddingDistanceEvalChain._aevaluate_stringssL2zz",9E- "  ##F++ 757rg)r3r4r5r6rrrrrrrrrrrrrrr rrr"r#rrr)sDBBB+DI++=A S#X 89  c3h  6BF S#X =>  c3h  >$(#$(-1!& , ,C= ,  , tCy! ,4S>* , , ,  ,L$(#$(-1!& , ,C= ,  , tCy! ,4S>* , , ,  ,r#rcFeZdZdZedeefdZedefdZ dde ee fde e de ee ffdZ dde ee fde ede ee ffd Zdddd d d ed edede eede e ee fdede de fdZdddd d d ed edede eede e ee fdede de fdZy)"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} rc ddgS)rr prediction_br"rOs rrz-PairwiseEmbeddingDistanceEvalChain.input_keyssn--r#c6d|jjdS)Npairwise_embedding_rrrOs rrz2PairwiseEmbeddingDistanceEvalChain.evaluation_names$T%9%9%?%?$@ JJr#Nrrc|jj|d|dg}trt}|j |}|j |}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. rrrNrrs rrz(PairwiseEmbeddingDistanceEvalChain._callsd//11|$~&   >Bhhw'G##G,r#cK|jj|d|dgd{}trt}|j |}|j |}d|iS7>w)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. rrNrNrrs rrz)PairwiseEmbeddingDistanceEvalChain._acallsr88|$~&    >Bhhw'G##G, rF)rrrrrrrrrrrc D|||d||||}|j|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. rrrr rPrrrrrrrrRs r_evaluate_string_pairsz9PairwiseEmbeddingDistanceEvalChain._evaluate_string_pairss54",lK-  ##F++r#crK|j||d||||d{}|j|S7w)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_pairs4sL8zz",lK- "  ##F++ rrg)r3r4r5r6rrrrrrrrrrrrr rrrr"r#rrrs.DI..KKK =A S#X 89  c3h  <BF S#X =>  c3h  @ $$(-1!&!,!, !,  !, tCy! !,4S>*!,!,!, !,P $$(-1!&#,#, #,  #, tCy! #,4S>*#,#,#, #,r#r))r6 functoolsloggingenumr importlibrtypingrr langchain_core.callbacks.managerrrr langchain_core.embeddingsr langchain_core.utilsr pydanticr r langchain.chains.baserlangchain.evaluation.schemarrlangchain.schemarr getLoggerr3r lru_cacherr$r+rr-r=rrr"r#rrsF  1)&'P$s   8 $Q d   J.T$J5JZV,!=V,rU, "9U,r#