3fiPdZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z m Z ddlmZdd lmZdd lmZmZdd lmZdd lmZdd lmZmZddlmZdefdZej>e Z!ejDdde#fdZ$defdZ%Gdde&eZ'GddeZ(Gdde(eZ)Gdde(eZ*y)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_KEYreturncN ddl}|S#t$r}d}t||d}~wwxYw)Nrz@Could not import numpy, please install with `pip install numpy`.)numpy ImportError)npemsgs r/var/www/auto_recruiter/arenv/lib/python3.12/site-packages/langchain_classic/evaluation/embedding_distance/base.py _import_numpyrs5& I &P#A%&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$r0 ddlm}n#t$r}d}t||d}~wwxYwY|SwxYw)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,2sl *5    * *  *Q c" )  *    *s) A A <7<AAc$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.Ks"FIIIGr$r.ceZdZUdZeeZeed<ee jZ e ed<e de eefde eeffdZed Zedeefd Zd e de fd Zde defdZedededefdZedededefdZedededefdZedededefdZedededefdZdedefdZy)_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\|jd}g} ddlm}|j| ddlm}|j||s d}t |t |t|r ddl}|S|S#t$rYPwxYw#t$rYGwxYw#t$r}d}t ||d}~wwxYw)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_installedhsZZ -   9 MM* +   MM* +Q c" " j%- 0 . v =       .I "#&A- .s:A1B)B1 A=<A= B  B  B+B&&B+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$resultcDd|di}t|vr|t|t<|S)NrOr)rQrSparseds r_prepare_outputz,_EmbeddingDistanceChainMixin._prepare_outputs*6'?+ f $WoF7O r$metricc <tj|jtj|jtj |j tj|jtj|ji}||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_metrics  $ $d&;&;  ' ')A)A  ' ')A)A  ' ')A)A  % %t'='=   W 6? " )or$abc h ddlm}d|||z S#t$r ddlm}||j |j cYS#t$rWt rt}|j }|j }|j||}|jj|}|jj|} |dk(s| dk(rYYyd||| zz z cYcYSt|dr|n|g}t|dr|n|g}t|dr|j }t|dr|j }tdt||d D}td |Dd z}td |Dd z} |dk(s| dk(rYYyd||| 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|] \}}||zywNr#.0xys r z@_EmbeddingDistanceChainMixin._cosine_distance..s!VDAq!a%!VsFstrictc3&K|] }||z ywrhr#rjrks rrmz@_EmbeddingDistanceChainMixin._cosine_distance..3qQU3?c3&K|] }||z ywrhr#rqs rrmz@_EmbeddingDistanceChainMixin._cosine_distance..rrrs)!langchain_core.vectorstores.utilsrdrscipy.spatial.distancer/rfr%rdotlinalgnormhasattrsumzip) rarbrdr/ra_flatb_flat dot_productnorm_anorm_bs rrYz-_EmbeddingDistanceChainMixin._cosine_distances# ? L+Aq11 1 ? ?9aiik199;77 ?>&BYY[FYY[F"$&&"8KYY^^F3FYY^^F3F{fk"+&"ABB%a3!%a3!1i(YY[F1i(YY[F!!VCu4U!VV 3F33s:3F33s:Q;&A+kVf_=>>3 ?  ?sR F1*A  F1 BF-F1 F-*F1.B,F-F1 F-(F1,F--F1c  ddlm}||j|jS#t$rRt r$ddl}|j 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)r0Nc38K|]\}}||z ||z zywrhr#ris rrmzC_EmbeddingDistanceChainMixin._euclidean_distance..s!MTQA!a%(MsFrnrt) rwr0rfrr%rryrzr|r})rarbr0rs rrZz0_EmbeddingDistanceChainMixin._euclidean_distancest U 8QYY[!))+6 6 U~"yy~~a!e,,MSAe5LMMQTT T  Us*-5B$!BBc & ddlm}||j|jS#t$rZt r/t }|j |j||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 ywrhabsris rrmzC_EmbeddingDistanceChainMixin._manhattan_distance..Fdas1q5zFFrn) rwrrfrr%rr|rr})rarbrrs rr[z0_EmbeddingDistanceChainMixin._manhattan_distancev G 8QYY[!))+6 6 G~"_vvbffQUm,,Fc!Qu.EFF F  G*-AB/BBc & ddlm}||j|jS#t$rZt r/t }|j |j||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 ywrhrris rrmzC_EmbeddingDistanceChainMixin._chebyshev_distance..1rrFrn) rwr2rfrr%rmaxrr})rarbr2rs rr\z0_EmbeddingDistanceChainMixin._chebyshev_distancerrc   ddlm}||j|jS#t$rWt r t }|j ||k7cYStdt||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)r3c32K|]\}}||k7s dyw)rNr#ris rrmzA_EmbeddingDistanceChainMixin._hamming_distance..GsGTQQqGs Frn) rwr3rfrr%rmeanr|r}len)rarbr3rs rr]z._EmbeddingDistanceChainMixin._hamming_distance3sv Q 6199; 4 4 Q~"_wwqAv&GSAe%<GG#a&P P  Qs*-1B  *B  B 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: The computed score. rr) r`rBr%rGrndarrayreshapeitemfloat)rQrrWrOs r_compute_scorez+_EmbeddingDistanceChainMixin._compute_scoreIs!!$"6"67 >j-/2I2IJ71:--a4gaj6H6HB6OPUUWEU|71:wqz2EU|r$N) r4r5r6r7r r,r@r __annotations__r.r8rBr dictstrrrLr model_configpropertylistrRrVr` staticmethodrYrZr[r\r]rrr#r$rr>r>]s#3EFJ F).7H7O7O)PO&P -$sCx.-T#s(^--^ $LT#Ydt "3*-?C-?C-?C-?-?^UsUsUsUU,GsGsGsGG*GsGsGsGG*QSQSQSQQ*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 fdZy)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} rcy)zReturn whether the chain requires a reference. Returns: True if a reference is required, `False` otherwise. Tr#rPs rrequires_referencez-EmbeddingDistanceEvalChain.requires_referencegsr$c6d|jjdS)N embedding_ _distancerBvaluerPs revaluation_namez*EmbeddingDistanceEvalChain.evaluation_nameps D00667yAAr$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|jj|d|dg}trt}|j |}|j |}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~sa//11 L !6+#6 7  >Bhhw'G##G,r$cK|jj|d|dgd{}trt}|j |}|j |}d|iS7>w)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._acallsr88|${#    >Bhhw'G##G, 'A*A(?A*F)r callbackstagsmetadatainclude_run_inforrrrrrkwargsc D|||d||||}|j|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_stringss56",9E-  ##F++r$crK|j||d||||d{}|j|S7w)rrrNacallrVrs r_aevaluate_stringsz-EmbeddingDistanceEvalChain._aevaluate_stringssL6zz",9E- "  ##F++ 757rh)r4r5r6r7rrrr rrrrrrrrrrrrrr#r$rrrZs D BBB+DI++:> S#X 0$6  c3h   .?C S#X 5t;  c3h   4 !%#!%*.!&!,!,: !,  !, 3i$ !,sCx.4'!,!,!, !,!,F !%#!%*.!&!,!,: !,  !, 3i$ !,sCx.4'!,!,!, !,!,r$rcneZdZdZedeefdZedefdZe 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 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#rPs rrz-PairwiseEmbeddingDistanceEvalChain.input_keyssn--r$c6d|jjdS)zReturn the evaluation name.pairwise_embedding_rrrPs rrz2PairwiseEmbeddingDistanceEvalChain.evaluation_names %T%9%9%?%?$@ JJr$Nrrc|jj|d|dg}trt}|j |}|j |}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._callsd//11|$~&   >Bhhw'G##G,r$cK|jj|d|dgd{}trt}|j |}|j |}d|iS7>w)zAsynchronously compute the score for two predictions. Args: inputs: The input data. run_manager: The callback manager. Returns: The computed score. rrNrOrrs rrz)PairwiseEmbeddingDistanceEvalChain._acall0sr88|$~&    >Bhhw'G##G, rF)rrrrrrrrrrrc D|||d||||}|j|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_pairsKs56",lK-  ##F++r$crK|j||d||||d{}|j|S7w)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_pairsosL6zz",lK- "  ##F++ rrh)r4r5r6r7rrrrrr rrrrrrrrrrr#r$rrrs.DI..KKK:> S#X 0$6  c3h   4?C S#X 5t;  c3h   4 $!%*.!&!,!, !,  !, 3i$ !,sCx.4'!,!,!, !,!,F $!%*.!&!,!, !,  !, 3i$ !,sCx.4'!,!,!, !,!,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$rrsF.1)&&/X,s   8 $Q d   J2T$z5zz],!=],@W, W,r$