tjPdZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z m Z ddlmZdd lmZdd lmZmZdd lmZdd lmZdd lmZmZddlmZdefdZeje Z!ej"dde#fdZ$defdZ%Gdde&eZ'GddeZ(Gdde(eZ)Gdde(eZ*dS)z@A chain for comparing the output of two models using embeddings.N)Enum)util)Any) Callbacks)AsyncCallbackManagerForChainRunCallbackManagerForChainRun) Embeddings)pre_init) ConfigDictField)override)Chain)PairwiseStringEvaluatorStringEvaluatorRUN_KEYreturncZ ddl}n$#t$r}d}t||d}~wwxYw|S)Nrz@Could not import numpy, please install with `pip install numpy`.)numpy ImportError)npemsgs r/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/langchain_classic/evaluation/embedding_distance/base.py _import_numpyrsQ& &&&P#A%& Is (#()maxsizecttjdrdStddS)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%$sC DN7 # #$$t NN  5r$c ddlm}n<#t$r/ ddlm}n$#t$r}d}t||d}~wwxYwYnwxYw|S)zZCreate an `Embeddings` object. Returns: The created `Embeddings` object. rOpenAIEmbeddingstCould not import OpenAIEmbeddings. Please install the OpenAIEmbeddings package using `pip install langchain-openai`.N)langchain_openair(r%langchain_community.embeddings.openai)r(rrs r_embedding_factoryr,2s *5555555  * * * *        * * *Q c"" )  *   *    s) AA <7<AAc&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 CHEBYSHEVHAMMINGr#r$rr.r.Ks3FIIIGGGr$r.ceZdZUdZeeZeed<ee j Z e ed<e de eefde eeffdZed Zedeefd Zd e de fd Zde defdZedededefdZedededefdZedededefdZedededefdZedededefdZdedefdZdS)_EmbeddingDistanceChainMixinzShared functionality for embedding distance evaluators. Attributes: embeddings: The embedding objects to vectorize the outputs. distance_metric: The distance metric to use for comparing the embeddings. )default_factory embeddings)defaultdistance_metricvaluesrc|d}g} ddlm}||n#t$rYnwxYw ddlm}||n#t$rYnwxYw|sd}t |t |t|r* ddl}n$#t$r}d}t ||d}~wwxYw|S)zValidate that the TikTok library is installed. Args: values: The values to validate. Returns: 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)clsrCr@types_r(rrIrs r_validate_tiktoken_installedz9_EmbeddingDistanceChainMixin._validate_tiktoken_installedhsRZZ --   9 9 9 9 9 9 MM* + + + +    D         MM* + + + +    D  #Q c"" " j%-- 0 0 . . . . .I "#&&A- . s95 AAA"" A/.A/#B(( C 2CC T)arbitrary_types_allowedcdgS)z\Return the output keys of the chain. Returns: The output keys. scorer#selfs r output_keysz(_EmbeddingDistanceChainMixin.output_keyss yr$resultcVd|di}t|vr|t|t<|S)NrOr)rQrSparseds r_prepare_outputz,_EmbeddingDistanceChainMixin._prepare_outputs-6'?+ f  $WoF7O r$metricc tj|jtj|jtj|jtj|jtj |j i}||vr||Sd|}t|)zGet the metric function for the given metric name. Args: metric: The metric name. Returns: The metric function. zInvalid metric: ) r.r8_cosine_distancer9_euclidean_distancer:_manhattan_distancer;_chebyshev_distancer<_hamming_distance ValueError)rQrWmetricsrs r _get_metricz(_EmbeddingDistanceChainMixin._get_metricsr  $d&;  ')A  ')A  ')A  %t'=   W  6? ")))oor$abc  ddlm}d|||z S#t$r ddlm}|||cYS#t$rt rt}|}|}|||}|j |}|j |} |dks| dkrYYdSd||| zz z cYcYSt|dr|n|g}t|dr|n|g}t|dr|}t|dr|}tdt||d D}td |Dd z}td |Dd z} |dks| dkrYYdSd||| zz z cYcYSwxYwwxYw)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_similarityg?)r/g__len__flattenc3&K|] \}}||zV dSNr#.0xys r z@_EmbeddingDistanceChainMixin._cosine_distance..s*!V!VDAq!a%!V!V!V!V!V!Vr$Fstrictc3 K|] }||zV dSrhr#rjrks rrmz@_EmbeddingDistanceChainMixin._cosine_distance..&33qQU333333r$?c3 K|] }||zV dSrhr#rqs rrmz@_EmbeddingDistanceChainMixin._cosine_distance..rrr$)!langchain_core.vectorstores.utilsrdrscipy.spatial.distancer/rfr%rdotlinalgnormhasattrsumzip) rarbrdr/ra_flatb_flat dot_productnorm_anorm_bs rrYz-_EmbeddingDistanceChainMixin._cosine_distancesc# ? L L L L L L++Aq111 1 ? ? ? ?999999vaiikk199;;77777 ? ? ?>> C&BYY[[FYY[[F"$&&"8"8KY^^F33FY^^F33F{{fkk"sss+&"ABBBBBB%a33<!%a33<!1i(()YY[[F1i(()YY[[F!!V!VCu4U4U4U!V!V!VVV 33F33333s:33F33333s:Q;;&A++333kVf_=>>>>>>3 ?  ?sR H 5AH B%HH  HH CH2H 6 HH HH c J ddlm}|||S#t$r`t r#ddl}|j||z cYStdt||dDdzcYSwxYw)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. r)r0Nc32K|]\}}||z ||z zVdSrhr#ris rrmzC_EmbeddingDistanceChainMixin._euclidean_distance..s3MMTQA!a%(MMMMMMr$Frnrs) rvr0rfrr%rrxryr{r|)rarbr0rs rrZz0_EmbeddingDistanceChainMixin._euclidean_distances U 8 8 8 8 8 89QYY[[!))++66 6 U U U~~ -""""y~~a!e,,,,,MMSAe5L5L5LMMMMMQTT T T T  Us589B"3,B"!B"c t ddlm}|||S#t$rut r;t }||||z cYSt dt||dDcYSwxYw)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. r) cityblockc3@K|]\}}t||z VdSrhabsris rrmzC_EmbeddingDistanceChainMixin._manhattan_distance..0FFdas1q5zzFFFFFFr$Frn) rvrrfrr%rr{rr|)rarbrrs rr[z0_EmbeddingDistanceChainMixin._manhattan_distance G 8 8 8 8 8 89QYY[[!))++66 6 G G G~~ -"__vvbffQUmm,,,,,FFc!Qu.E.E.EFFFFF F F F  G58AB7 )B76B7c t ddlm}|||S#t$rut r;t }||||z cYSt dt||dDcYSwxYw)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. r)r2c3@K|]\}}t||z VdSrhrris rrmzC_EmbeddingDistanceChainMixin._chebyshev_distance..1rr$Frn) rvr2rfrr%rmaxrr|)rarbr2rs rr\z0_EmbeddingDistanceChainMixin._chebyshev_distancerrc p ddlm}|||S#t$rst r)t }|||kcYStdt||dDt|z cYSwxYw)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. r)r3c3,K|]\}}||k dVdS)rNr#ris rrmzA_EmbeddingDistanceChainMixin._hamming_distance..Gs*GGTQQqGGr$Frn) rvr3rfrr%rmeanr{r|len)rarbr3rs rr]z._EmbeddingDistanceChainMixin._hamming_distance3s Q 6 6 6 6 6 67199;; 44 4 Q Q Q~~ '"__wwqAv&&&GGSAe%<%<%<GGGGG#a&&P P P P  Qs58?B599B54B5vectorsc||j}trtt|t jrS||ddd|ddd}n||d|d}t|S)zCompute the score based on the distance metric. Args: vectors (np.ndarray): The input vectors. Returns: The computed score. rr) r`rBr%rGrndarrayreshapeitemfloat)rQrrWrOs r_compute_scorez+_EmbeddingDistanceChainMixin._compute_scoreIs!!$"677 >> 3j-//2IJJ 3F71:--a44gaj6H6HB6O6OPPUUWWEEF71:wqz22EU||r$N) r4r5r6r7r r,r@r __annotations__r.r8rBr dictstrrrLr model_configpropertylistrRrVr` staticmethodrYrZr[r\r]rrr#r$rr>r>]sr#U3EFFFJ FFF).7H7O)P)P)PO&PPP -$sCx.-T#s(^---X-^: $LT#YXdt "3*-?C-?C-?C-?-?-?\-?^UsUsUsUUU\U,GsGsGsGGG\G*GsGsGsGGG\G*QSQSQSQQQ\Q*cer$r>ceZdZdZedefdZeedefdZ ede efdZ e dde ee fdedzde ee ffd Ze dde ee fdedzde ee ffd Zeddddd d d ededzdede edzde ee fdzdede de fdZeddddd d d ededzdede edzde ee fdzdede de fdZdS)EmbeddingDistanceEvalChainaLEmbedding distance evaluation chain. 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} rcdS)zReturn whether the chain requires a reference. Returns: True if a reference is required, `False` otherwise. Tr#rPs rrequires_referencez-EmbeddingDistanceEvalChain.requires_referencegs tr$c"d|jjdS)N embedding_ _distancerBvaluerPs revaluation_namez*EmbeddingDistanceEvalChain.evaluation_namepsBD06AAAAr$c ddgS)ZReturn the input keys of the chain. Returns: The input keys. prediction referencer#rPs r input_keysz%EmbeddingDistanceEvalChain.input_keysusk**r$Ninputs run_managerc|j|d|dg}tr#t}||}||}d|iS)zCompute the score for a prediction and reference. Args: inputs: The input data. run_manager: The callback manager. Returns: The computed score. rrrOr@embed_documentsr%rarrayrrQrrrrrOs r_callz EmbeddingDistanceEvalChain._call~ss/11 L !6+#6 7   >> (Bhhw''G##G,,r$cK|j|d|dgd{V}tr#t}||}||}d|iS)zAsynchronously compute the score for a prediction and reference. Args: inputs: The input data. run_manager: The callback manager. Returns: The computed score. rrNrOr@aembed_documentsr%rrrrs r_acallz!EmbeddingDistanceEvalChain._acalls88|${#          >> (Bhhw''G##G,,r$F)r callbackstagsmetadatainclude_run_inforrrrrrkwargsc R|||d||||}||S)ZEvaluate the embedding distance between a prediction and reference. Args: prediction: The output string from the first model. reference: The output string from the second model. callbacks: The callbacks to use. tags: The tags to apply. metadata: The metadata to use. include_run_info: Whether to include run information in the output. **kwargs: Additional keyword arguments. Returns: `dict` containing: - score: The embedding distance between the two predictions. rrrrrrrrV rQrrrrrrrrSs r_evaluate_stringsz,EmbeddingDistanceEvalChain._evaluate_stringssG6",9EE-    ##F+++r$cvK|||d||||d{V}||S)rrrNacallrVrs r_aevaluate_stringsz-EmbeddingDistanceEvalChain._aevaluate_stringssk6zz",9EE- "        ##F+++r$rh)r4r5r6r7rrrr rrrrrrrrrrrrrr#r$rrrZs  DX BBBBXXB+DI+++X+:>  S#X 0$6  c3h    X .?C  S#X 5t;  c3h    X 4 !%#!%*.!&!,!,!,!,: !,  !, 3i$ !,sCx.4'!,!,!, !,!,!,X!,F !%#!%*.!&!,!,!,!,: !,  !, 3i$ !,sCx.4'!,!,!, !,!,!,X!,!,!,r$rceZdZdZedeefdZedefdZe dde ee fde dzde ee ffdZ e dde ee fdedzde ee ffd Ze dddd d d ed ededeedzde ee fdzdede de fdZe dddd d d ed ededeedzde ee fdzdede de fdZdS)"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#rPs rrz-PairwiseEmbeddingDistanceEvalChain.input_keyssn--r$c"d|jjdS)zReturn the evaluation name.pairwise_embedding_rrrPs rrz2PairwiseEmbeddingDistanceEvalChain.evaluation_namesKT%9%?JJJJr$Nrrc|j|d|dg}tr#t}||}||}d|iS)zCompute the score for two predictions. Args: inputs: The input data. run_manager: The callback manager. Returns: The computed score. rrrOrrs rrz(PairwiseEmbeddingDistanceEvalChain._callsv/11|$~&    >> (Bhhw''G##G,,r$cK|j|d|dgd{V}tr#t}||}||}d|iS)zAsynchronously compute the score for two predictions. Args: inputs: The input data. run_manager: The callback manager. Returns: The computed score. rrNrOrrs rrz)PairwiseEmbeddingDistanceEvalChain._acall0s88|$~&          >> (Bhhw''G##G,,r$F)rrrrrrrrrrrc R|||d||||}||S)aREvaluate the embedding distance between two predictions. Args: prediction: The output string from the first model. prediction_b: The output string from the second model. callbacks: The callbacks to use. tags: The tags to apply. metadata: The metadata to use. include_run_info: Whether to include run information in the output. **kwargs: Additional keyword arguments. Returns: `dict` containing: - score: The embedding distance between the two predictions. rrrr rQrrrrrrrrSs r_evaluate_string_pairsz9PairwiseEmbeddingDistanceEvalChain._evaluate_string_pairsKsG6",lKK-    ##F+++r$cvK|||d||||d{V}||S)aaAsynchronously evaluate the embedding distance between two predictions. Args: prediction: The output string from the first model. prediction_b: The output string from the second model. callbacks: The callbacks to use. tags: The tags to apply. metadata: The metadata to use. include_run_info: Whether to include run information in the output. **kwargs: Additional keyword arguments. Returns: `dict` containing: - score: The embedding distance between the two predictions. rrNrrs r_aevaluate_string_pairsz:PairwiseEmbeddingDistanceEvalChain._aevaluate_string_pairsosk6zz",lKK- "        ##F+++r$rh)r4r5r6r7rrrrrr rrrrrrrrrrr#r$rrrsi.DI...X.KKKKXK:>  S#X 0$6  c3h    X 4?C  S#X 5t;  c3h    X 4 $!%*.!&!,!,!,!, !,  !, 3i$ !,sCx.4'!,!,!, !,!,!,X!,F $!%*.!&!,!,!,!, !,  !, 3i$ !,sCx.4'!,!,!, !,!,!,X!,!,!,r$r)+r7 functoolsloggingenumr importlibrtypingrlangchain_core.callbacksr langchain_core.callbacks.managerrrlangchain_core.embeddingsr langchain_core.utilsr pydanticr r typing_extensionsr langchain_classic.chains.baser#langchain_classic.evaluation.schemarrlangchain_classic.schemarr getLoggerr4r! lru_cacherr%r,rr.r>rrr#r$rrsuFF......100000))))))&&&&&&&&&&&&&&//////XXXXXXXX,,,,,,s  8 $ $Q d     J2T$zzzzz5zzzz],],],],],!=],],],@W,W,W,W,W, W,W,W,W,W,r$