jJ~dZddlZddlZddlmZddlmZddlmZm Z ddl m Z ddl m Z mZddlmZdd lmZdd lmZmZdd lmZdd lmZmZdd lmZdefdZej<eZ ejBdde"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)AnyOptional) Callbacks)AsyncCallbackManagerForChainRunCallbackManagerForChainRun) Embeddings)pre_init) ConfigDictField)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 v/var/www/html/Fitness-lenito-AI-main/venv/lib/python3.12/site-packages/langchain/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)zaCreate an Embeddings object. Returns: Embeddings: 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,1sl *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.Is"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_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 (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)clsrCr@types_r(rrIrs r_validate_tiktoken_installedz9_EmbeddingDistanceChainMixin._validate_tiktoken_installedgsZZ -   9 MM* +   MM* +Q c" " j%- 0 . v =       .I "#&A- .s:A1B)B1 A=<A= B  B  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)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 (EmbeddingDistance): The metric name. Returns: Any: 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$abcf ddlm}d|||z S#t$r}d}t||d}~wwxYw)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`.Ng?)langchain_community.utils.mathrdr)rarbrdrrs rrYz-_EmbeddingDistanceChainMixin._cosine_distancesJ * H&q!,,, *6  c" )  *s 0+0ctr"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%rlinalgnormsumziprarbrs rrZz0_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 ywrhabsris rrmzC_EmbeddingDistanceChainMixin._manhattan_distance..4)$!Q3q1u:))r%rrprvrqrrs rr[z0_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 ywrhruris rrmzC_EmbeddingDistanceChainMixin._chebyshev_distance..rwrx)r%rmaxrvrqrrs rr\z0_EmbeddingDistanceChainMixin._chebyshev_distanceryr$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#ris rrmzA_EmbeddingDistanceChainMixin._hamming_distance..s5Aa1f1s )r%rmeanrprqlenrrs rr]z._EmbeddingDistanceChainMixin._hamming_distance sB >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`rBr%rGrndarrayreshapeitemfloat)rQrrWrOs r_compute_scorez+_EmbeddingDistanceChainMixin._compute_scores!!$"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--*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#rPs rrequires_referencez-EmbeddingDistanceEvalChain.requires_reference6sr$c6d|jjdS)N embedding_ _distancerBvaluerPs revaluation_namez*EmbeddingDistanceEvalChain.evaluation_name?sD00667yAAr$c ddgS)eReturn the input keys of the chain. Returns: List[str]: The input keys. prediction referencer#rPs r input_keysz%EmbeddingDistanceEvalChain.input_keysCsk**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. rrrOr@embed_documentsr%rarrayrrQrrrrrOs r_callz EmbeddingDistanceEvalChain._callLsa//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. rrNrOr@aembed_documentsr%rrrrs r_acallz!EmbeddingDistanceEvalChain._acalldsr88|${#    >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. rrrrrrrrV rQrrrrrrrrSs r_evaluate_stringsz,EmbeddingDistanceEvalChain._evaluate_stringss52",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. rrNacallrVrs r_aevaluate_stringsz-EmbeddingDistanceEvalChain._aevaluate_stringssL2zz",9E- "  ##F++ 757rh)r4r5r6r7rrrrrrrrrrr rrrrrrr#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#rPs rrz-PairwiseEmbeddingDistanceEvalChain.input_keyssn--r$c6d|jjdS)Npairwise_embedding_rrrPs 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. rrrOrrs 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. rrNrOrrs 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 rQrrrrrrrrSs 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_pairs7sL8zz",lK- "  ##F++ rrh)r4r5r6r7rrrrrrrrr rrrrrrrr#r$rrrs.DI..KKK =A S#X 89  c3h  <BF S#X =>  c3h  @ $$(-1!&!,!, !,  !, tCy! !,4S>*!,!,!, !,P $$(-1!&#,#, #,  #, tCy! #,4S>*#,#,#, #,r$r)*r7 functoolsloggingenumr importlibrtypingrrlangchain_core.callbacksr langchain_core.callbacks.managerrr langchain_core.embeddingsr langchain_core.utilsr pydanticr r langchain.chains.baserlangchain.evaluation.schemarrlangchain.schemarr getLoggerr4r! lru_cacherr%r,rr.r>rrr#r$rrsF .1)&'P$s   8 $Q d   J0T$M5M`V,!=V,rV, V,r$