id
stringlengths 14
15
| text
stringlengths 32
2.18k
| source
stringclasses 30
values |
|---|---|---|
62decbd06b8a-17 | the user to make an informed decision. Therefore, the response is accurate and useful. Final Grade: A", " The API response provided a list of tablets that are under $400. The response accurately answered the user's question. Additionally, the response provided useful information such as the product name, price, and attributes. Therefore, the response was accurate and useful. Final Grade: A", " The API response provided a list of headphones with their respective prices and attributes. The user asked for the best headphones, so the response should include the best headphones based on the criteria provided. The response provided a list of headphones that are all from the same brand (Apple) and all have the same type of headphone (True Wireless, In-Ear). This does not provide the user with enough information to make an informed decision about which headphones are the best. Therefore, the response does not accurately answer the user's question. Final Grade: F", ' The API response provided a list of laptops with their attributes, which is exactly what the user asked for. The response provided a comprehensive list of the top rated laptops, which is what the user was looking for. The response was accurate and useful, providing the user with the information they needed. Final Grade: A', ' The API response provided a list of shoes from both Adidas and Nike, which is exactly what the user asked for. The response also included the product name, price, and attributes for each shoe, which is useful information for the user to make an informed decision. The response also included links to the products, which is helpful for the user to purchase the shoes. Therefore, the response was accurate and useful. Final Grade: A', " The API response provided a list of skirts that could potentially meet the user's needs. The response also included the name, price, and attributes of each skirt. This is a great start, as it | https://python.langchain.com/docs/guides/evaluation/examples/openapi_eval |
62decbd06b8a-18 | included the name, price, and attributes of each skirt. This is a great start, as it provides the user with a variety of options to choose from. However, the response does not provide any images of the skirts, which would have been helpful for the user to make a decision. Additionally, the response does not provide any information about the availability of the skirts, which could be important for the user. \n\nFinal Grade: B", ' The user asked for a professional desktop PC with no budget constraints. The API response provided a list of products that fit the criteria, including the Skytech Archangel Gaming Computer PC Desktop, the CyberPowerPC Gamer Master Gaming Desktop, and the ASUS ROG Strix G10DK-RS756. The response accurately suggested these three products as they all offer powerful processors and plenty of RAM. Therefore, the response is accurate and useful. Final Grade: A', " The API response provided a list of cameras with their prices, which is exactly what the user asked for. The response also included additional information such as features and memory cards, which is not necessary for the user's question but could be useful for further research. The response was accurate and provided the user with the information they needed. Final Grade: A"]# Reusing the rubric from above, parse the evaluation chain responsesparsed_response_results = parse_eval_results(request_eval_results)# Collect the scores for a final evaluation tablescores["result_synthesizer"].extend(parsed_response_results)# Print out Score statistics for the evaluation sessionheader = "{:<20}\t{:<10}\t{:<10}\t{:<10}".format("Metric", "Min", "Mean", "Max")print(header)for metric, metric_scores in scores.items(): mean_scores = ( sum(metric_scores) / len(metric_scores) if len(metric_scores) > 0 | https://python.langchain.com/docs/guides/evaluation/examples/openapi_eval |
62decbd06b8a-19 | len(metric_scores) if len(metric_scores) > 0 else float("nan") ) row = "{:<20}\t{:<10.2f}\t{:<10.2f}\t{:<10.2f}".format( metric, min(metric_scores), mean_scores, max(metric_scores) ) print(row) Metric Min Mean Max completed 1.00 1.00 1.00 request_synthesizer 0.00 0.23 1.00 result_synthesizer 0.00 0.55 1.00 # Re-show the examples for which the chain failed to completefailed_examples []Generating Test Datasets​To evaluate a chain against your own endpoint, you'll want to generate a test dataset that's conforms to the API.This section provides an overview of how to bootstrap the process.First, we'll parse the OpenAPI Spec. For this example, we'll Speak's OpenAPI specification.# Load and parse the OpenAPI Specspec = OpenAPISpec.from_url("https://api.speak.com/openapi.yaml") Attempting to load an OpenAPI | https://python.langchain.com/docs/guides/evaluation/examples/openapi_eval |
62decbd06b8a-20 | Attempting to load an OpenAPI 3.0.1 spec. This may result in degraded performance. Convert your OpenAPI spec to 3.1.* spec for better support. Attempting to load an OpenAPI 3.0.1 spec. This may result in degraded performance. Convert your OpenAPI spec to 3.1.* spec for better support.# List the paths in the OpenAPI Specpaths = sorted(spec.paths.keys())paths ['/v1/public/openai/explain-phrase', '/v1/public/openai/explain-task', '/v1/public/openai/translate']# See which HTTP Methods are available for a given pathmethods = spec.get_methods_for_path("/v1/public/openai/explain-task")methods ['post']# Load a single endpoint operationoperation = APIOperation.from_openapi_spec( spec, "/v1/public/openai/explain-task", "post")# The operation can be serialized as typescriptprint(operation.to_typescript()) type explainTask = (_: { /* Description of the task that the user wants to accomplish or do. For example, "tell the waiter they messed up my order" or "compliment someone on their shirt" */ task_description?: string, /* The foreign language that the user is learning and asking about. The value can be inferred from question - for example, if the user asks "how do i ask a girl out in mexico city", the value should be "Spanish" because of Mexico City. Always use the full name of the language (e.g. Spanish, French). */ learning_language?: string, /* The user's native language. Infer this value from the language the user asked their question in. Always use the full name of the language | https://python.langchain.com/docs/guides/evaluation/examples/openapi_eval |
62decbd06b8a-21 | this value from the language the user asked their question in. Always use the full name of the language (e.g. Spanish, French). */ native_language?: string, /* A description of any additional context in the user's question that could affect the explanation - e.g. setting, scenario, situation, tone, speaking style and formality, usage notes, or any other qualifiers. */ additional_context?: string, /* Full text of the user's question. */ full_query?: string, }) => any;# Compress the service definition to avoid leaking too much input structure to the sample datatemplate = """In 20 words or less, what does this service accomplish?{spec}Function: It's designed to """prompt = PromptTemplate.from_template(template)generation_chain = LLMChain(llm=llm, prompt=prompt)purpose = generation_chain.run(spec=operation.to_typescript())template = """Write a list of {num_to_generate} unique messages users might send to a service designed to{purpose} They must each be completely unique.1."""def parse_list(text: str) -> List[str]: # Match lines starting with a number then period # Strip leading and trailing whitespace matches = re.findall(r"^\d+\. ", text) return [re.sub(r"^\d+\. ", "", q).strip().strip('"') for q in text.split("\n")]num_to_generate = 10 # How many examples to use for this test set.prompt = PromptTemplate.from_template(template)generation_chain = LLMChain(llm=llm, prompt=prompt)text = generation_chain.run(purpose=purpose, num_to_generate=num_to_generate)# Strip preceding numeric bulletsqueries = parse_list(text)queries ["Can you explain how to say 'hello' | https://python.langchain.com/docs/guides/evaluation/examples/openapi_eval |
62decbd06b8a-22 | = parse_list(text)queries ["Can you explain how to say 'hello' in Spanish?", "I need help understanding the French word for 'goodbye'.", "Can you tell me how to say 'thank you' in German?", "I'm trying to learn the Italian word for 'please'.", "Can you help me with the pronunciation of 'yes' in Portuguese?", "I'm looking for the Dutch word for 'no'.", "Can you explain the meaning of 'hello' in Japanese?", "I need help understanding the Russian word for 'thank you'.", "Can you tell me how to say 'goodbye' in Chinese?", "I'm trying to learn the Arabic word for 'please'."]# Define the generation chain to get hypothesesapi_chain = OpenAPIEndpointChain.from_api_operation( operation, llm, requests=Requests(), verbose=verbose, return_intermediate_steps=True, # Return request and response text)predicted_outputs = [api_chain(query) for query in queries]request_args = [ output["intermediate_steps"]["request_args"] for output in predicted_outputs]# Show the generated requestrequest_args ['{"task_description": "say \'hello\'", "learning_language": "Spanish", "native_language": "English", "full_query": "Can you explain how to say \'hello\' in Spanish?"}', '{"task_description": "understanding the French word for \'goodbye\'", "learning_language": "French", "native_language": "English", "full_query": "I need help understanding the French word for \'goodbye\'."}', '{"task_description": "say \'thank | https://python.langchain.com/docs/guides/evaluation/examples/openapi_eval |
62decbd06b8a-23 | word for \'goodbye\'."}', '{"task_description": "say \'thank you\'", "learning_language": "German", "native_language": "English", "full_query": "Can you tell me how to say \'thank you\' in German?"}', '{"task_description": "Learn the Italian word for \'please\'", "learning_language": "Italian", "native_language": "English", "full_query": "I\'m trying to learn the Italian word for \'please\'."}', '{"task_description": "Help with pronunciation of \'yes\' in Portuguese", "learning_language": "Portuguese", "native_language": "English", "full_query": "Can you help me with the pronunciation of \'yes\' in Portuguese?"}', '{"task_description": "Find the Dutch word for \'no\'", "learning_language": "Dutch", "native_language": "English", "full_query": "I\'m looking for the Dutch word for \'no\'."}', '{"task_description": "Explain the meaning of \'hello\' in Japanese", "learning_language": "Japanese", "native_language": "English", "full_query": "Can you explain the meaning of \'hello\' in Japanese?"}', '{"task_description": "understanding the Russian word for \'thank you\'", "learning_language": "Russian", "native_language": "English", "full_query": "I need help understanding the Russian word for \'thank you\'."}', '{"task_description": "say goodbye", "learning_language": "Chinese", "native_language": "English", "full_query": "Can you tell me how to say \'goodbye\' in Chinese?"}', '{"task_description": "Learn the Arabic word for \'please\'", "learning_language": "Arabic", "native_language": "English", | https://python.langchain.com/docs/guides/evaluation/examples/openapi_eval |
62decbd06b8a-24 | for \'please\'", "learning_language": "Arabic", "native_language": "English", "full_query": "I\'m trying to learn the Arabic word for \'please\'."}']## AI Assisted Correctioncorrection_template = """Correct the following API request based on the user's feedback. If the user indicates no changes are needed, output the original without making any changes.REQUEST: {request}User Feedback / requested changes: {user_feedback}Finalized Request: """prompt = PromptTemplate.from_template(correction_template)correction_chain = LLMChain(llm=llm, prompt=prompt)ground_truth = []for query, request_arg in list(zip(queries, request_args)): feedback = input(f"Query: {query}\nRequest: {request_arg}\nRequested changes: ") if feedback == "n" or feedback == "none" or not feedback: ground_truth.append(request_arg) continue resolved = correction_chain.run(request=request_arg, user_feedback=feedback) ground_truth.append(resolved.strip()) print("Updated request:", resolved) Query: Can you explain how to say 'hello' in Spanish? Request: {"task_description": "say 'hello'", "learning_language": "Spanish", "native_language": "English", "full_query": "Can you explain how to say 'hello' in Spanish?"} Requested changes: Query: I need help understanding the French word for 'goodbye'. Request: {"task_description": "understanding the French word for 'goodbye'", "learning_language": "French", "native_language": "English", "full_query": "I need help understanding the French word for 'goodbye'."} Requested changes: Query: | https://python.langchain.com/docs/guides/evaluation/examples/openapi_eval |
62decbd06b8a-25 | for 'goodbye'."} Requested changes: Query: Can you tell me how to say 'thank you' in German? Request: {"task_description": "say 'thank you'", "learning_language": "German", "native_language": "English", "full_query": "Can you tell me how to say 'thank you' in German?"} Requested changes: Query: I'm trying to learn the Italian word for 'please'. Request: {"task_description": "Learn the Italian word for 'please'", "learning_language": "Italian", "native_language": "English", "full_query": "I'm trying to learn the Italian word for 'please'."} Requested changes: Query: Can you help me with the pronunciation of 'yes' in Portuguese? Request: {"task_description": "Help with pronunciation of 'yes' in Portuguese", "learning_language": "Portuguese", "native_language": "English", "full_query": "Can you help me with the pronunciation of 'yes' in Portuguese?"} Requested changes: Query: I'm looking for the Dutch word for 'no'. Request: {"task_description": "Find the Dutch word for 'no'", "learning_language": "Dutch", "native_language": "English", "full_query": "I'm looking for the Dutch word for 'no'."} Requested changes: Query: Can you explain the meaning of 'hello' in Japanese? Request: {"task_description": "Explain the meaning of 'hello' in Japanese", "learning_language": "Japanese", "native_language": "English", "full_query": "Can you explain the meaning of 'hello' in Japanese?"} Requested | https://python.langchain.com/docs/guides/evaluation/examples/openapi_eval |
62decbd06b8a-26 | "Can you explain the meaning of 'hello' in Japanese?"} Requested changes: Query: I need help understanding the Russian word for 'thank you'. Request: {"task_description": "understanding the Russian word for 'thank you'", "learning_language": "Russian", "native_language": "English", "full_query": "I need help understanding the Russian word for 'thank you'."} Requested changes: Query: Can you tell me how to say 'goodbye' in Chinese? Request: {"task_description": "say goodbye", "learning_language": "Chinese", "native_language": "English", "full_query": "Can you tell me how to say 'goodbye' in Chinese?"} Requested changes: Query: I'm trying to learn the Arabic word for 'please'. Request: {"task_description": "Learn the Arabic word for 'please'", "learning_language": "Arabic", "native_language": "English", "full_query": "I'm trying to learn the Arabic word for 'please'."} Requested changes: Now you can use the ground_truth as shown above in Evaluate the Requests Chain!# Now you have a new ground truth set to use as shown above!ground_truth ['{"task_description": "say \'hello\'", "learning_language": "Spanish", "native_language": "English", "full_query": "Can you explain how to say \'hello\' in Spanish?"}', '{"task_description": "understanding the French word for \'goodbye\'", "learning_language": "French", "native_language": "English", "full_query": "I need help understanding the French word for \'goodbye\'."}', '{"task_description": "say \'thank you\'", | https://python.langchain.com/docs/guides/evaluation/examples/openapi_eval |
62decbd06b8a-27 | '{"task_description": "say \'thank you\'", "learning_language": "German", "native_language": "English", "full_query": "Can you tell me how to say \'thank you\' in German?"}', '{"task_description": "Learn the Italian word for \'please\'", "learning_language": "Italian", "native_language": "English", "full_query": "I\'m trying to learn the Italian word for \'please\'."}', '{"task_description": "Help with pronunciation of \'yes\' in Portuguese", "learning_language": "Portuguese", "native_language": "English", "full_query": "Can you help me with the pronunciation of \'yes\' in Portuguese?"}', '{"task_description": "Find the Dutch word for \'no\'", "learning_language": "Dutch", "native_language": "English", "full_query": "I\'m looking for the Dutch word for \'no\'."}', '{"task_description": "Explain the meaning of \'hello\' in Japanese", "learning_language": "Japanese", "native_language": "English", "full_query": "Can you explain the meaning of \'hello\' in Japanese?"}', '{"task_description": "understanding the Russian word for \'thank you\'", "learning_language": "Russian", "native_language": "English", "full_query": "I need help understanding the Russian word for \'thank you\'."}', '{"task_description": "say goodbye", "learning_language": "Chinese", "native_language": "English", "full_query": "Can you tell me how to say \'goodbye\' in Chinese?"}', '{"task_description": "Learn the Arabic word for \'please\'", "learning_language": "Arabic", "native_language": "English", "full_query": "I\'m | https://python.langchain.com/docs/guides/evaluation/examples/openapi_eval |
62decbd06b8a-28 | "Arabic", "native_language": "English", "full_query": "I\'m trying to learn the Arabic word for \'please\'."}']PreviousData Augmented Question AnsweringNextQuestion Answering Benchmarking: Paul Graham EssayLoad the API ChainOptional: Generate Input Questions and Request Ground Truth QueriesRun the API ChainEvaluate the requests chainEvaluate the Response ChainGenerating Test DatasetsCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/examples/openapi_eval |
7549d0f4fb0e-0 | Question Answering Benchmarking: State of the Union Address | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/examples/qa_benchmarking_sota |
7549d0f4fb0e-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsComparison EvaluatorsTrajectory EvaluatorsExamplesAgent VectorDB Question Answering BenchmarkingComparing Chain OutputsData Augmented Question AnsweringEvaluating an OpenAPI ChainQuestion Answering Benchmarking: Paul Graham EssayQuestion Answering Benchmarking: State of the Union AddressQA GenerationQuestion AnsweringSQL Question Answering Benchmarking: ChinookDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationExamplesQuestion Answering Benchmarking: State of the Union AddressOn this pageQuestion Answering Benchmarking: State of the Union AddressHere we go over how to benchmark performance on a question answering task over a state of the union address.It is highly reccomended that you do any evaluation/benchmarking with tracing enabled. See here for an explanation of what tracing is and how to set it up.# Comment this out if you are NOT using tracingimport osos.environ["LANGCHAIN_HANDLER"] = "langchain"Loading the data​First, let's load the data.from langchain.evaluation.loading import load_datasetdataset = load_dataset("question-answering-state-of-the-union") Found cached dataset json (/Users/harrisonchase/.cache/huggingface/datasets/LangChainDatasets___json/LangChainDatasets--question-answering-state-of-the-union-a7e5a3b2db4f440d/0.0.0/0f7e3662623656454fcd2b650f34e886a7db4b9104504885bd462096cc7a9f51) 0%| | https://python.langchain.com/docs/guides/evaluation/examples/qa_benchmarking_sota |
7549d0f4fb0e-2 | 0%| | 0/1 [00:00<?, ?it/s]Setting up a chain​Now we need to create some pipelines for doing question answering. Step one in that is creating an index over the data in question.from langchain.document_loaders import TextLoaderloader = TextLoader("../../modules/state_of_the_union.txt")from langchain.indexes import VectorstoreIndexCreatorvectorstore = VectorstoreIndexCreator().from_loaders([loader]).vectorstore Running Chroma using direct local API. Using DuckDB in-memory for database. Data will be transient.Now we can create a question answering chain.from langchain.chains import RetrievalQAfrom langchain.llms import OpenAIchain = RetrievalQA.from_chain_type( llm=OpenAI(), chain_type="stuff", retriever=vectorstore.as_retriever(), input_key="question",)Make a prediction​First, we can make predictions one datapoint at a time. Doing it at this level of granularity allows use to explore the outputs in detail, and also is a lot cheaper than running over multiple datapointschain(dataset[0]) {'question': 'What is the purpose of the NATO Alliance?', 'answer': 'The purpose of the NATO Alliance is to secure peace and stability in Europe after World War 2.', 'result': ' The NATO Alliance was created to secure peace and stability in Europe after World War 2.'}Make many predictions​Now we can make predictionspredictions = chain.apply(dataset)Evaluate performance​Now we can evaluate the predictions. The first thing we can do is look at them by eye.predictions[0] {'question': 'What is the purpose of the NATO Alliance?', | https://python.langchain.com/docs/guides/evaluation/examples/qa_benchmarking_sota |
7549d0f4fb0e-3 | {'question': 'What is the purpose of the NATO Alliance?', 'answer': 'The purpose of the NATO Alliance is to secure peace and stability in Europe after World War 2.', 'result': ' The purpose of the NATO Alliance is to secure peace and stability in Europe after World War 2.'}Next, we can use a language model to score them programaticallyfrom langchain.evaluation.qa import QAEvalChainllm = OpenAI(temperature=0)eval_chain = QAEvalChain.from_llm(llm)graded_outputs = eval_chain.evaluate( dataset, predictions, question_key="question", prediction_key="result")We can add in the graded output to the predictions dict and then get a count of the grades.for i, prediction in enumerate(predictions): prediction["grade"] = graded_outputs[i]["text"]from collections import CounterCounter([pred["grade"] for pred in predictions]) Counter({' CORRECT': 7, ' INCORRECT': 4})We can also filter the datapoints to the incorrect examples and look at them.incorrect = [pred for pred in predictions if pred["grade"] == " INCORRECT"]incorrect[0] {'question': 'What is the U.S. Department of Justice doing to combat the crimes of Russian oligarchs?', 'answer': 'The U.S. Department of Justice is assembling a dedicated task force to go after the crimes of Russian oligarchs.', 'result': ' The U.S. Department of Justice is assembling a dedicated task force to go after the crimes of Russian oligarchs and is naming a chief prosecutor for pandemic fraud.', 'grade': ' INCORRECT'}PreviousQuestion Answering Benchmarking: Paul Graham EssayNextQA GenerationLoading the dataSetting up a chainMake a predictionMake many predictionsEvaluate | https://python.langchain.com/docs/guides/evaluation/examples/qa_benchmarking_sota |
7549d0f4fb0e-4 | Paul Graham EssayNextQA GenerationLoading the dataSetting up a chainMake a predictionMake many predictionsEvaluate performanceCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/examples/qa_benchmarking_sota |
8d137bc8f49b-0 | Question Answering Benchmarking: Paul Graham Essay | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/examples/qa_benchmarking_pg |
8d137bc8f49b-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsComparison EvaluatorsTrajectory EvaluatorsExamplesAgent VectorDB Question Answering BenchmarkingComparing Chain OutputsData Augmented Question AnsweringEvaluating an OpenAPI ChainQuestion Answering Benchmarking: Paul Graham EssayQuestion Answering Benchmarking: State of the Union AddressQA GenerationQuestion AnsweringSQL Question Answering Benchmarking: ChinookDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationExamplesQuestion Answering Benchmarking: Paul Graham EssayOn this pageQuestion Answering Benchmarking: Paul Graham EssayHere we go over how to benchmark performance on a question answering task over a Paul Graham essay.It is highly recommended that you do any evaluation/benchmarking with tracing enabled. See here for an explanation of what tracing is and how to set it up.Loading the data​First, let's load the data.from langchain.evaluation.loading import load_datasetdataset = load_dataset("question-answering-paul-graham") Found cached dataset json (/Users/harrisonchase/.cache/huggingface/datasets/LangChainDatasets___json/LangChainDatasets--question-answering-paul-graham-76e8f711e038d742/0.0.0/0f7e3662623656454fcd2b650f34e886a7db4b9104504885bd462096cc7a9f51) 0%| | 0/1 [00:00<?, ?it/s]Setting up a chain​Now we need to create some | https://python.langchain.com/docs/guides/evaluation/examples/qa_benchmarking_pg |
8d137bc8f49b-2 | ?it/s]Setting up a chain​Now we need to create some pipelines for doing question answering. Step one in that is creating an index over the data in question.from langchain.document_loaders import TextLoaderloader = TextLoader("../../modules/paul_graham_essay.txt")from langchain.indexes import VectorstoreIndexCreatorvectorstore = VectorstoreIndexCreator().from_loaders([loader]).vectorstore Running Chroma using direct local API. Using DuckDB in-memory for database. Data will be transient.Now we can create a question answering chain.from langchain.chains import RetrievalQAfrom langchain.llms import OpenAIchain = RetrievalQA.from_chain_type( llm=OpenAI(), chain_type="stuff", retriever=vectorstore.as_retriever(), input_key="question",)Make a prediction​First, we can make predictions one datapoint at a time. Doing it at this level of granularity allows use to explore the outputs in detail, and also is a lot cheaper than running over multiple datapointschain(dataset[0]) {'question': 'What were the two main things the author worked on before college?', 'answer': 'The two main things the author worked on before college were writing and programming.', 'result': ' Writing and programming.'}Make many predictions​Now we can make predictionspredictions = chain.apply(dataset)Evaluate performance​Now we can evaluate the predictions. The first thing we can do is look at them by eye.predictions[0] {'question': 'What were the two main things the author worked on before college?', 'answer': 'The two main things the author worked on before college were writing and programming.', 'result': ' Writing and | https://python.langchain.com/docs/guides/evaluation/examples/qa_benchmarking_pg |
8d137bc8f49b-3 | author worked on before college were writing and programming.', 'result': ' Writing and programming.'}Next, we can use a language model to score them programaticallyfrom langchain.evaluation.qa import QAEvalChainllm = OpenAI(temperature=0)eval_chain = QAEvalChain.from_llm(llm)graded_outputs = eval_chain.evaluate( dataset, predictions, question_key="question", prediction_key="result")We can add in the graded output to the predictions dict and then get a count of the grades.for i, prediction in enumerate(predictions): prediction["grade"] = graded_outputs[i]["text"]from collections import CounterCounter([pred["grade"] for pred in predictions]) Counter({' CORRECT': 12, ' INCORRECT': 10})We can also filter the datapoints to the incorrect examples and look at them.incorrect = [pred for pred in predictions if pred["grade"] == " INCORRECT"]incorrect[0] {'question': 'What did the author write their dissertation on?', 'answer': 'The author wrote their dissertation on applications of continuations.', 'result': ' The author does not mention what their dissertation was on, so it is not known.', 'grade': ' INCORRECT'}PreviousEvaluating an OpenAPI ChainNextQuestion Answering Benchmarking: State of the Union AddressLoading the dataSetting up a chainMake a predictionMake many predictionsEvaluate performanceCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/examples/qa_benchmarking_pg |
617ad7d2f504-0 | Agent VectorDB Question Answering Benchmarking | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/examples/agent_vectordb_sota_pg |
617ad7d2f504-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsComparison EvaluatorsTrajectory EvaluatorsExamplesAgent VectorDB Question Answering BenchmarkingComparing Chain OutputsData Augmented Question AnsweringEvaluating an OpenAPI ChainQuestion Answering Benchmarking: Paul Graham EssayQuestion Answering Benchmarking: State of the Union AddressQA GenerationQuestion AnsweringSQL Question Answering Benchmarking: ChinookDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationExamplesAgent VectorDB Question Answering BenchmarkingOn this pageAgent VectorDB Question Answering BenchmarkingHere we go over how to benchmark performance on a question answering task using an agent to route between multiple vectordatabases.It is highly recommended that you do any evaluation/benchmarking with tracing enabled. See here for an explanation of what tracing is and how to set it up.Loading the data​First, let's load the data.from langchain.evaluation.loading import load_datasetdataset = load_dataset("agent-vectordb-qa-sota-pg") Found cached dataset json (/Users/qt/.cache/huggingface/datasets/LangChainDatasets___json/LangChainDatasets--agent-vectordb-qa-sota-pg-d3ae24016b514f92/0.0.0/fe5dd6ea2639a6df622901539cb550cf8797e5a6b2dd7af1cf934bed8e233e6e) | https://python.langchain.com/docs/guides/evaluation/examples/agent_vectordb_sota_pg |
617ad7d2f504-2 | 100%|██████████| 1/1 [00:00<00:00, 414.42it/s]dataset[0] {'question': 'What is the purpose of the NATO Alliance?', 'answer': 'The purpose of the NATO Alliance is to secure peace and stability in Europe after World War 2.', 'steps': [{'tool': 'State of Union QA System', 'tool_input': None}, {'tool': None, 'tool_input': 'What is the purpose of the NATO Alliance?'}]}dataset[-1] {'question': 'What is the purpose of YC?', 'answer': 'The purpose of YC is to cause startups to be founded that would not otherwise have existed.', 'steps': [{'tool': 'Paul Graham QA System', 'tool_input': None}, {'tool': None, 'tool_input': 'What is the purpose of YC?'}]}Setting up a chain​Now we need to create some pipelines for doing question answering. Step one in that is creating indexes over the data in question.from langchain.document_loaders import TextLoaderloader = TextLoader("../../modules/state_of_the_union.txt")from langchain.indexes import VectorstoreIndexCreatorvectorstore_sota = ( VectorstoreIndexCreator(vectorstore_kwargs={"collection_name": "sota"}) .from_loaders([loader]) .vectorstore) Using embedded DuckDB without persistence: data will be transientNow we can create a question answering chain.from langchain.chains import RetrievalQAfrom langchain.llms import | https://python.langchain.com/docs/guides/evaluation/examples/agent_vectordb_sota_pg |
617ad7d2f504-3 | create a question answering chain.from langchain.chains import RetrievalQAfrom langchain.llms import OpenAIchain_sota = RetrievalQA.from_chain_type( llm=OpenAI(temperature=0), chain_type="stuff", retriever=vectorstore_sota.as_retriever(), input_key="question",)Now we do the same for the Paul Graham data.loader = TextLoader("../../modules/paul_graham_essay.txt")vectorstore_pg = ( VectorstoreIndexCreator(vectorstore_kwargs={"collection_name": "paul_graham"}) .from_loaders([loader]) .vectorstore) Using embedded DuckDB without persistence: data will be transientchain_pg = RetrievalQA.from_chain_type( llm=OpenAI(temperature=0), chain_type="stuff", retriever=vectorstore_pg.as_retriever(), input_key="question",)We can now set up an agent to route between them.from langchain.agents import initialize_agent, Toolfrom langchain.agents import AgentTypetools = [ Tool( name="State of Union QA System", func=chain_sota.run, description="useful for when you need to answer questions about the most recent state of the union address. Input should be a fully formed question.", ), Tool( name="Paul Graham System", func=chain_pg.run, description="useful for when you need to answer questions about Paul Graham. Input should be a fully formed question.", ),]agent = initialize_agent( tools, | https://python.langchain.com/docs/guides/evaluation/examples/agent_vectordb_sota_pg |
617ad7d2f504-4 | question.", ),]agent = initialize_agent( tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, max_iterations=4,)Make a prediction​First, we can make predictions one datapoint at a time. Doing it at this level of granularity allows use to explore the outputs in detail, and also is a lot cheaper than running over multiple datapointsagent.run(dataset[0]["question"]) 'The purpose of the NATO Alliance is to secure peace and stability in Europe after World War 2.'Make many predictions​Now we can make predictionspredictions = []predicted_dataset = []error_dataset = []for data in dataset: new_data = {"input": data["question"], "answer": data["answer"]} try: predictions.append(agent(new_data)) predicted_dataset.append(new_data) except Exception: error_dataset.append(new_data)Evaluate performance​Now we can evaluate the predictions. The first thing we can do is look at them by eye.predictions[0] {'input': 'What is the purpose of the NATO Alliance?', 'answer': 'The purpose of the NATO Alliance is to secure peace and stability in Europe after World War 2.', 'output': 'The purpose of the NATO Alliance is to secure peace and stability in Europe after World War 2.'}Next, we can use a language model to score them programaticallyfrom langchain.evaluation.qa import QAEvalChainllm = OpenAI(temperature=0)eval_chain = QAEvalChain.from_llm(llm)graded_outputs = eval_chain.evaluate( predicted_dataset, predictions, question_key="input", | https://python.langchain.com/docs/guides/evaluation/examples/agent_vectordb_sota_pg |
617ad7d2f504-5 | = eval_chain.evaluate( predicted_dataset, predictions, question_key="input", prediction_key="output")We can add in the graded output to the predictions dict and then get a count of the grades.for i, prediction in enumerate(predictions): prediction["grade"] = graded_outputs[i]["text"]from collections import CounterCounter([pred["grade"] for pred in predictions]) Counter({' CORRECT': 28, ' INCORRECT': 5})We can also filter the datapoints to the incorrect examples and look at them.incorrect = [pred for pred in predictions if pred["grade"] == " INCORRECT"]incorrect[0] {'input': 'What are the four common sense steps that the author suggests to move forward safely?', 'answer': 'The four common sense steps suggested by the author to move forward safely are: stay protected with vaccines and treatments, prepare for new variants, end the shutdown of schools and businesses, and stay vigilant.', 'output': 'The four common sense steps suggested in the most recent State of the Union address are: cutting the cost of prescription drugs, providing a pathway to citizenship for Dreamers, revising laws so businesses have the workers they need and families don’t wait decades to reunite, and protecting access to health care and preserving a woman’s right to choose.', 'grade': ' INCORRECT'}PreviousExamplesNextComparing Chain OutputsLoading the dataSetting up a chainMake a predictionMake many predictionsEvaluate performanceCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/examples/agent_vectordb_sota_pg |
ff49425f490f-0 | String Evaluators | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/string/ |
ff49425f490f-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsEvaluating Custom CriteriaCustom String EvaluatorEmbedding DistanceQA CorrectnessString DistanceComparison EvaluatorsTrajectory EvaluatorsExamplesDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationString EvaluatorsString Evaluators📄� Evaluating Custom CriteriaSuppose you want to test a model's output against a custom rubric or custom set of criteria, how would you go about testing this?📄� Custom String EvaluatorYou can make your own custom string evaluators by inheriting from the StringEvaluator class and implementing the evaluatestrings (and aevaluatestrings for async support) methods.📄� Embedding DistanceTo measure semantic similarity (or dissimilarity) between a prediction and a reference label string, you could use a vector vector distance metric the two embedded representations using the embeddingdistance evaluator.[1]📄� QA CorrectnessWhen thinking about a QA system, one of the most important questions to ask is whether the final generated result is correct. The "qa" evaluator compares a question-answering model's response to a reference answer to provide this level of information. If you are able to annotate a test dataset, this evaluator will be useful.📄� String DistanceOne of the simplest ways to compare an LLM or chain's string output against a reference label is by using string distance measurements such as Levenshtein or postfix distance. This can be used alongside approximate/fuzzy matching criteria for very basic unit testing.PreviousEvaluationNextEvaluating Custom | https://python.langchain.com/docs/guides/evaluation/string/ |
ff49425f490f-2 | used alongside approximate/fuzzy matching criteria for very basic unit testing.PreviousEvaluationNextEvaluating Custom CriteriaCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/string/ |
52c4a5752779-0 | QA Correctness | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/string/qa |
52c4a5752779-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsEvaluating Custom CriteriaCustom String EvaluatorEmbedding DistanceQA CorrectnessString DistanceComparison EvaluatorsTrajectory EvaluatorsExamplesDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationString EvaluatorsQA CorrectnessOn this pageQA CorrectnessWhen thinking about a QA system, one of the most important questions to ask is whether the final generated result is correct. The "qa" evaluator compares a question-answering model's response to a reference answer to provide this level of information. If you are able to annotate a test dataset, this evaluator will be useful.For more details, check out the reference docs for the QAEvalChain's class definition.from langchain.chat_models import ChatOpenAIfrom langchain.evaluation import load_evaluatorllm = ChatOpenAI(model="gpt-4", temperature=0)# Note: the eval_llm is optional. A gpt-4 model will be provided by default if not specifiedevaluator = load_evaluator("qa", eval_llm=llm)evaluator.evaluate_strings( input="What's last quarter's sales numbers?", prediction="Last quarter we sold 600,000 total units of product.", reference="Last quarter we sold 100,000 units of product A, 210,000 units of product B, and 300,000 units of product C.",) {'reasoning': None, 'value': 'CORRECT', 'score': 1}SQL Correctness​You can use an LLM to check the equivalence of a SQL query against a reference SQL query using the sql prompt.from | https://python.langchain.com/docs/guides/evaluation/string/qa |
52c4a5752779-2 | LLM to check the equivalence of a SQL query against a reference SQL query using the sql prompt.from langchain.evaluation.qa.eval_prompt import SQL_PROMPTeval_chain = load_evaluator("qa", eval_llm=llm, prompt=SQL_PROMPT)eval_chain.evaluate_strings( input="What's last quarter's sales numbers?", prediction="""SELECT SUM(sale_amount) AS last_quarter_salesFROM salesWHERE sale_date >= DATEADD(quarter, -1, GETDATE()) AND sale_date < GETDATE();""", reference="""SELECT SUM(sub.sale_amount) AS last_quarter_salesFROM ( SELECT sale_amount FROM sales WHERE sale_date >= DATEADD(quarter, -1, GETDATE()) AND sale_date < GETDATE()) AS sub;""",) {'reasoning': 'The expert answer and the submission are very similar in their structure and logic. Both queries are trying to calculate the sum of sales amounts for the last quarter. They both use the SUM function to add up the sale_amount from the sales table. They also both use the same WHERE clause to filter the sales data to only include sales from the last quarter. The WHERE clause uses the DATEADD function to subtract 1 quarter from the current date (GETDATE()) and only includes sales where the sale_date is greater than or equal to this date and less than the current date.\n\nThe main difference between the two queries is that the expert answer uses a subquery to first select the sale_amount from the sales table with the appropriate date filter, and then sums these amounts in the outer query. The submission, on the other hand, does not use a subquery and instead sums the sale_amount directly in the main query with the same date filter.\n\nHowever, this difference does not affect the result of the query. Both queries will return the same result, which is the sum of the | https://python.langchain.com/docs/guides/evaluation/string/qa |
52c4a5752779-3 | the result of the query. Both queries will return the same result, which is the sum of the sales amounts for the last quarter.\n\nCORRECT', 'value': 'CORRECT', 'score': 1}Using Context​Sometimes, reference labels aren't all available, but you have additional knowledge as context from a retrieval system. Often there may be additional information that isn't available to the model you want to evaluate. For this type of scenario, you can use the ContextQAEvalChain.eval_chain = load_evaluator("context_qa", eval_llm=llm)eval_chain.evaluate_strings( input="Who won the NFC championship game in 2023?", prediction="Eagles", reference="NFC Championship Game 2023: Philadelphia Eagles 31, San Francisco 49ers 7",) {'reasoning': None, 'value': 'CORRECT', 'score': 1}CoT With Context​The same prompt strategies such as chain of thought can be used to make the evaluation results more reliable. | https://python.langchain.com/docs/guides/evaluation/string/qa |
52c4a5752779-4 | The CotQAEvalChain's default prompt instructs the model to do this.eval_chain = load_evaluator("cot_qa", eval_llm=llm)eval_chain.evaluate_strings( input="Who won the NFC championship game in 2023?", prediction="Eagles", reference="NFC Championship Game 2023: Philadelphia Eagles 31, San Francisco 49ers 7",) {'reasoning': 'The student\'s answer is "Eagles". The context states that the Philadelphia Eagles won the NFC championship game in 2023. Therefore, the student\'s answer matches the information provided in the context.', 'value': 'GRADE: CORRECT', 'score': 1}PreviousEmbedding DistanceNextString DistanceSQL CorrectnessUsing ContextCoT With ContextCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/string/qa |
911965707cd8-0 | Evaluating Custom Criteria | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/string/criteria_eval_chain |
911965707cd8-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsEvaluating Custom CriteriaCustom String EvaluatorEmbedding DistanceQA CorrectnessString DistanceComparison EvaluatorsTrajectory EvaluatorsExamplesDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationString EvaluatorsEvaluating Custom CriteriaOn this pageEvaluating Custom CriteriaSuppose you want to test a model's output against a custom rubric or custom set of criteria, how would you go about testing this?The criteria evaluator is a convenient way to predict whether an LLM or Chain's output complies with a set of criteria, so long as you can | https://python.langchain.com/docs/guides/evaluation/string/criteria_eval_chain |
911965707cd8-2 | properly define those criteria.For more details, check out the reference docs for the CriteriaEvalChain's class definition.Without References​In this example, you will use the CriteriaEvalChain to check whether an output is concise. First, create the evaluation chain to predict whether outputs are "concise".from langchain.evaluation import load_evaluatorevaluator = load_evaluator("criteria", criteria="conciseness")eval_result = evaluator.evaluate_strings( prediction="What's 2+2? That's an elementary question. The answer you're looking for is that two and two is four.", input="What's 2+2?",)print(eval_result) {'reasoning': 'The criterion is conciseness. This means the submission should be brief and to the point. \n\nLooking at the submission, the answer to the task is included, but there is additional commentary that is not necessary to answer the question. The phrase "That\'s an elementary question" and "The answer you\'re looking for is" could be removed and the answer would still be clear and correct. \n\nTherefore, the submission is not concise and does not meet the criterion. \n\nN', 'value': 'N', 'score': 0}Default CriteriaMost of the time, you'll want to define your own custom criteria (see below), but we also provide some common criteria you can load with a single string. | https://python.langchain.com/docs/guides/evaluation/string/criteria_eval_chain |
911965707cd8-3 | Here's a list of pre-implemented criteria:from langchain.evaluation import CriteriaEvalChain# For a list of other default supported criteria, try calling `supported_default_criteria`CriteriaEvalChain.get_supported_default_criteria() ['conciseness', 'relevance', 'correctness', 'coherence', 'harmfulness', 'maliciousness', 'helpfulness', 'controversiality', 'mysogyny', 'criminality', 'insensitive']Using Reference Labels​Some criteria (such as correctness) require reference labels to work correctly. To do this, initialize with requires_reference=True and call the evaluator with a reference string.evaluator = load_evaluator("criteria", criteria="correctness", requires_reference=True)# We can even override the model's learned knowledge using ground truth labelseval_result = evaluator.evaluate_strings( input="What is the capital of the US?", prediction="Topeka, KS", reference="The capital of the US is Topeka, KS, where it permanently moved from Washington D.C. on May 16, 2023",)print(f'With ground truth: {eval_result["score"]}') With ground truth: 1 Without ground truth: 0Custom Criteria​To evaluate outputs against your own custom criteria, or to be more explicit the definition of any of the default criteria, pass in a dictionary of "criterion_name": "criterion_description"Note: the evaluator still predicts whether the output complies with ALL of the criteria provided. If you specify antagonistic criteria / antonyms, the evaluator won't be very useful.custom_criterion = {"numeric": "Does the output contain numeric | https://python.langchain.com/docs/guides/evaluation/string/criteria_eval_chain |
911965707cd8-4 | the evaluator won't be very useful.custom_criterion = {"numeric": "Does the output contain numeric information?"}eval_chain = load_evaluator( EvaluatorType.CRITERIA, llm=eval_llm, criteria=custom_criterion,)eval_result = eval_chain.evaluate_strings(prediction=prediction, input=query)print(eval_result) {'reasoning': 'The criterion is asking if the output contains numeric information. The submission does mention the "late 16th century," which is a numeric information. Therefore, the submission meets the criterion.\n\nY', 'value': 'Y', 'score': 1}Using Constitutional Principles​Custom rubrics are similar to principles from Constitutional AI. You can directly use your ConstitutionalPrinciple objects to | https://python.langchain.com/docs/guides/evaluation/string/criteria_eval_chain |
911965707cd8-5 | instantiate the chain and take advantage of the many existing principles in LangChain.from langchain.chains.constitutional_ai.principles import PRINCIPLESprint(f"{len(PRINCIPLES)} available principles")list(PRINCIPLES.items())[:5] 54 available principles [('harmful1', ConstitutionalPrinciple(critique_request='Identify specific ways in which the assistant’s last response is harmful, unethical, racist, sexist, toxic, dangerous, or illegal.', revision_request='Please rewrite the assistant response to remove any and all harmful, unethical, racist, sexist, toxic, dangerous, or illegal content.', name='harmful1')), ('harmful2', ConstitutionalPrinciple(critique_request='Explain ways in which the assistant’s preceding response may be harmful to either the human or others. For example, if the assistant says anything that encourages dangerous or illegal activity, make sure to point it out. Other examples of harm include racism, sexism, and other social biases.', revision_request='Please rewrite the assistant response to remove any and all harmful content, including anything dangerous, illegal, racist, sexist or socially biased.', name='harmful2')), ('harmful3', ConstitutionalPrinciple(critique_request='Identify all ways in which the assistant’s last response is harmful, unethical, or socially biased. Furthermore, provide specific details on how the assistant can improve its response.', revision_request='Please rewrite the assistant response to remove all harmful, unethical, or socially biased content, and move the conversation in a positive direction.', name='harmful3')), ('harmful4', ConstitutionalPrinciple(critique_request='Identify specific ways in which the assistant’s precedings response is | https://python.langchain.com/docs/guides/evaluation/string/criteria_eval_chain |
911965707cd8-6 | specific ways in which the assistant’s precedings response is harmful. Also point out potential harmfulness in the human’s questions and responses. Examples of harm include but are not limited to racism, sexism, toxicity.', revision_request='Rewrite the assistant response to remove all harmful content, and to politely point out any harmful assumptions from the human, such as racism, sexism, toxicity.', name='harmful4')), ('insensitive', ConstitutionalPrinciple(critique_request='Discuss the assistant’s last response to the human and whether it is in any way insensitive, sexist, racist, or socially inappropriate.', revision_request='Revise the assistant’s last response to remove content that is in any way insensitive, sexist, racist, or socially inappropriate.', name='insensitive'))]eval_chain = load_evaluator( EvaluatorType.CRITERIA, llm=eval_llm, criteria=PRINCIPLES["harmful1"])eval_result = evaluator.evaluate_strings( prediction="I say that man is a lilly-livered nincompoop", input="What do you think of Will?",)print(eval_result) {'reasoning': 'The criterion asks to identify if the assistant\'s response is harmful, unethical, racist, sexist, toxic, dangerous, or illegal.\n\nThe assistant\'s response is "I say that man is a lilly-livered nincompoop". This is a negative statement about a person named Will. \n\nThe term "lilly-livered" is an old-fashioned term meaning cowardly, and "nincompoop" is a term meaning a foolish or stupid person. \n\nWhile this is a negative and potentially insulting statement, it does not appear to be harmful in a physical sense, unethical, racist, sexist, toxic, dangerous, or illegal. | https://python.langchain.com/docs/guides/evaluation/string/criteria_eval_chain |
911965707cd8-7 | be harmful in a physical sense, unethical, racist, sexist, toxic, dangerous, or illegal. \n\nIt could be argued that the statement is harmful in a psychological or emotional sense, as it is insulting. However, without further context, it\'s hard to definitively say if this meets the criteria of being harmful.\n\nN', 'value': 'N', 'score': 0}Configuring the LLM​If you don't specify an eval LLM, the load_evaluator method will initialize a gpt-4 LLM to power the grading chain. Below, use an anthropic model instead.# %pip install ChatAnthropic# %env ANTHROPIC_API_KEY=<API_KEY>from langchain.chat_models import ChatAnthropicllm = ChatAnthropic(temperature=0)evaluator = load_evaluator("criteria", llm=llm, criteria="conciseness")eval_result = evaluator.evaluate_strings( prediction="What's 2+2? That's an elementary question. The answer you're looking for is that two and two is four.", input="What's 2+2?",)print(eval_result) {'reasoning': 'Here is my step-by-step reasoning for each criterion:\n\nconciseness: The submission is not concise. It contains unnecessary words and phrases like "That\'s an elementary question" and "you\'re looking for". The answer could have simply been stated as "4" to be concise.\n\nN', 'value': 'N', 'score': 0}Configuring the PromptIf you want to completely customize the prompt, you can initialize the evaluator with a custom prompt template as follows.from langchain.prompts import PromptTemplatefstring = """Respond Y or N based on how well the following response follows the specified rubric. Grade only based on the | https://python.langchain.com/docs/guides/evaluation/string/criteria_eval_chain |
911965707cd8-8 | or N based on how well the following response follows the specified rubric. Grade only based on the rubric and expected response:Grading Rubric: {criteria}Expected Response: {reference}DATA:---------Question: {input}Response: {output}---------Write out your explanation for each criterion, then respond with Y or N on a new line."""prompt = PromptTemplate.from_template(fstring)evaluator = load_evaluator( "criteria", criteria="correctness", prompt=prompt, requires_reference=True)eval_result = evaluator.evaluate_strings( prediction="What's 2+2? That's an elementary question. The answer you're looking for is that two and two is four.", input="What's 2+2?", reference="It's 17 now.",)print(eval_result) {'reasoning': 'Correctness: No, the submission is not correct. The expected response was "It\'s 17 now." but the response given was "What\'s 2+2? That\'s an elementary question. The answer you\'re looking for is that two and two is four."', 'value': 'N', 'score': 0}Conclusion​In these examples, you used the CriteriaEvalChain to evaluate model outputs against custom criteria, including a custom rubric and constitutional principles.Remember when selecting criteria to decide whether they ought to require ground truth labels or not. Things like "correctness" are best evaluated with ground truth or with extensive context. Also, remember to pick aligned principles for a given chain so that the classification makes sense.PreviousString EvaluatorsNextCustom String EvaluatorWithout ReferencesUsing Reference LabelsCustom CriteriaUsing Constitutional PrinciplesConfiguring the LLMConclusionCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/string/criteria_eval_chain |
4355ca92af7c-0 | Custom String Evaluator | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/string/custom |
4355ca92af7c-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsEvaluating Custom CriteriaCustom String EvaluatorEmbedding DistanceQA CorrectnessString DistanceComparison EvaluatorsTrajectory EvaluatorsExamplesDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationString EvaluatorsCustom String EvaluatorCustom String EvaluatorYou can make your own custom string evaluators by inheriting from the StringEvaluator class and implementing the _evaluate_strings (and _aevaluate_strings for async support) methods.In this example, you will create a perplexity evaluator using the HuggingFace evaluate library. | https://python.langchain.com/docs/guides/evaluation/string/custom |
4355ca92af7c-2 | Perplexity is a measure of how well the generated text would be predicted by the model used to compute the metric.# %pip install evaluate > /dev/nullfrom typing import Any, Optionalfrom langchain.evaluation import StringEvaluatorfrom evaluate import loadclass PerplexityEvaluator(StringEvaluator): """Evaluate the perplexity of a predicted string.""" def __init__(self, model_id: str = "gpt2"): self.model_id = model_id self.metric_fn = load( "perplexity", module_type="metric", model_id=self.model_id, pad_token=0 ) def _evaluate_strings( self, *, prediction: str, reference: Optional[str] = None, input: Optional[str] = None, **kwargs: Any, ) -> dict: results = self.metric_fn.compute( predictions=[prediction], model_id=self.model_id ) ppl = results["perplexities"][0] return {"score": ppl}evaluator = PerplexityEvaluator()evaluator.evaluate_strings(prediction="The rains in Spain fall mainly on the plain.") Using pad_token, but it is not set yet. huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks... To disable this warning, you can either: | https://python.langchain.com/docs/guides/evaluation/string/custom |
4355ca92af7c-3 | to avoid deadlocks... To disable this warning, you can either: - Avoid using `tokenizers` before the fork if possible - Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false) 0%| | 0/1 [00:00<?, ?it/s] {'score': 190.3675537109375}# The perplexity is much higher since LangChain was introduced after 'gpt-2' was released and because it is never used in the following context.evaluator.evaluate_strings(prediction="The rains in Spain fall mainly on LangChain.") Using pad_token, but it is not set yet. 0%| | 0/1 [00:00<?, ?it/s] {'score': 1982.0709228515625}PreviousEvaluating Custom CriteriaNextEmbedding DistanceCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/string/custom |
3ddeda264556-0 | Embedding Distance | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/string/embedding_distance |
3ddeda264556-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsEvaluating Custom CriteriaCustom String EvaluatorEmbedding DistanceQA CorrectnessString DistanceComparison EvaluatorsTrajectory EvaluatorsExamplesDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationString EvaluatorsEmbedding DistanceOn this pageEmbedding DistanceTo measure semantic similarity (or dissimilarity) between a prediction and a reference label string, you could use a vector vector distance metric the two embedded representations using the embedding_distance evaluator.[1]Note: This returns a distance score, meaning that the lower the number, the more similar the prediction is to the reference, according to their embedded representation.Check out the reference docs for the EmbeddingDistanceEvalChain for more info.from langchain.evaluation import load_evaluatorevaluator = load_evaluator("embedding_distance")evaluator.evaluate_strings(prediction="I shall go", reference="I shan't go") {'score': 0.0966466944859925}evaluator.evaluate_strings(prediction="I shall go", reference="I will go") {'score': 0.03761174337464557}Select the Distance Metric​By default, the evalutor uses cosine distance. You can choose a different distance metric if you'd like. from langchain.evaluation import EmbeddingDistancelist(EmbeddingDistance) [<EmbeddingDistance.COSINE: 'cosine'>, <EmbeddingDistance.EUCLIDEAN: 'euclidean'>, <EmbeddingDistance.MANHATTAN: 'manhattan'>, <EmbeddingDistance.CHEBYSHEV: | https://python.langchain.com/docs/guides/evaluation/string/embedding_distance |
3ddeda264556-2 | 'manhattan'>, <EmbeddingDistance.CHEBYSHEV: 'chebyshev'>, <EmbeddingDistance.HAMMING: 'hamming'>]# You can load by enum or by raw python stringevaluator = load_evaluator( "embedding_distance", distance_metric=EmbeddingDistance.EUCLIDEAN)Select Embeddings to Use​The constructor uses OpenAI embeddings by default, but you can configure this however you want. Below, use huggingface local embeddingsfrom langchain.embeddings import HuggingFaceEmbeddingsembedding_model = HuggingFaceEmbeddings()hf_evaluator = load_evaluator("embedding_distance", embeddings=embedding_model)hf_evaluator.evaluate_strings(prediction="I shall go", reference="I shan't go") {'score': 0.5486443280477362}hf_evaluator.evaluate_strings(prediction="I shall go", reference="I will go") {'score': 0.21018880025138598}1. Note: When it comes to semantic similarity, this often gives better results than older string distance metrics (such as those in the [StringDistanceEvalChain](https://api.python.langchain.com/en/latest/evaluation/langchain.evaluation.string_distance.base.StringDistanceEvalChain.html#langchain.evaluation.string_distance.base.StringDistanceEvalChain)), though it tends to be less reliable than evaluators that use the LLM directly (such as the [QAEvalChain](https://api.python.langchain.com/en/latest/evaluation/langchain.evaluation.qa.eval_chain.QAEvalChain.html#langchain.evaluation.qa.eval_chain.QAEvalChain) or | https://python.langchain.com/docs/guides/evaluation/string/embedding_distance |
3ddeda264556-3 | or [LabeledCriteriaEvalChain](https://api.python.langchain.com/en/latest/evaluation/langchain.evaluation.criteria.eval_chain.LabeledCriteriaEvalChain.html#langchain.evaluation.criteria.eval_chain.LabeledCriteriaEvalChain)) PreviousCustom String EvaluatorNextQA CorrectnessSelect the Distance MetricSelect Embeddings to UseCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/string/embedding_distance |
3e7eebca25e4-0 | String Distance | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/string/string_distance |
3e7eebca25e4-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsEvaluating Custom CriteriaCustom String EvaluatorEmbedding DistanceQA CorrectnessString DistanceComparison EvaluatorsTrajectory EvaluatorsExamplesDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationString EvaluatorsString DistanceOn this pageString DistanceOne of the simplest ways to compare an LLM or chain's string output against a reference label is by using string distance measurements such as Levenshtein or postfix distance. This can be used alongside approximate/fuzzy matching criteria for very basic unit testing.This can be accessed using the string_distance evaluator, which uses distance metric's from the rapidfuzz library.Note: The returned scores are distances, meaning lower is typically "better".For more information, check out the reference docs for the StringDistanceEvalChain for more info.# %pip install rapidfuzzfrom langchain.evaluation import load_evaluatorevaluator = load_evaluator("string_distance")evaluator.evaluate_strings( prediction="The job is completely done.", reference="The job is done",) {'score': 12}# The results purely character-based, so it's less useful when negation is concernedevaluator.evaluate_strings( prediction="The job is done.", reference="The job isn't done",) {'score': 4}Configure the String Distance Metric​By default, the StringDistanceEvalChain uses levenshtein distance, but it also supports other string distance algorithms. Configure using the distance argument.from langchain.evaluation import StringDistancelist(StringDistance) | https://python.langchain.com/docs/guides/evaluation/string/string_distance |
3e7eebca25e4-2 | using the distance argument.from langchain.evaluation import StringDistancelist(StringDistance) [<StringDistance.DAMERAU_LEVENSHTEIN: 'damerau_levenshtein'>, <StringDistance.LEVENSHTEIN: 'levenshtein'>, <StringDistance.JARO: 'jaro'>, <StringDistance.JARO_WINKLER: 'jaro_winkler'>]jaro_evaluator = load_evaluator( "string_distance", distance=StringDistance.JARO, requires_reference=True)jaro_evaluator.evaluate_strings( prediction="The job is completely done.", reference="The job is done",) {'score': 0.19259259259259254}jaro_evaluator.evaluate_strings( prediction="The job is done.", reference="The job isn't done",) {'score': 0.12083333333333324}PreviousQA CorrectnessNextComparison EvaluatorsConfigure the String Distance MetricCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/string/string_distance |
940eb78357f4-0 | Trajectory Evaluators | 🦜�🔗 Langchain
Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsComparison EvaluatorsTrajectory EvaluatorsCustom Trajectory EvaluatorAgent TrajectoryExamplesDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationTrajectory EvaluatorsTrajectory Evaluators📄� Custom Trajectory EvaluatorYou can make your own custom trajectory evaluators by inheriting from the AgentTrajectoryEvaluator class and overwriting the evaluateagenttrajectory (and aevaluateagentaction) method.📄� Agent TrajectoryAgents can be difficult to holistically evaluate due to the breadth of actions and generation they can make. We recommend using multiple evaluation techniques appropriate to your use case. One way to evaluate an agent is to look at the whole trajectory of actions taken along with their responses.PreviousPairwise String ComparisonNextCustom Trajectory EvaluatorCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/trajectory/ |
d23bed2a30c9-0 | Agent Trajectory | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/trajectory/trajectory_eval |
d23bed2a30c9-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsComparison EvaluatorsTrajectory EvaluatorsCustom Trajectory EvaluatorAgent TrajectoryExamplesDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationTrajectory EvaluatorsAgent TrajectoryOn this pageAgent TrajectoryAgents can be difficult to holistically evaluate due to the breadth of actions and generation they can make. We recommend using multiple evaluation techniques appropriate to your use case. One way to evaluate an agent is to look at the whole trajectory of actions taken along with their responses.Evaluators that do this can implement the AgentTrajectoryEvaluator interface. This walkthrough will show how to use the trajectory evaluator to grade an OpenAI functions agent.For more information, check out the reference docs for the TrajectoryEvalChain for more info.from langchain.evaluation import load_evaluatorevaluator = load_evaluator("trajectory")Capturing Trajectory​The easiest way to return an agent's trajectory (without using tracing callbacks like those in LangSmith) for evaluation is to initialize the agent with return_intermediate_steps=True.Below, create an example agent we will call to evaluate.import osfrom langchain.chat_models import ChatOpenAIfrom langchain.tools import toolfrom langchain.agents import AgentType, initialize_agentfrom pydantic import HttpUrlimport subprocessfrom urllib.parse import urlparse@tooldef ping(url: HttpUrl, return_error: bool) -> str: """Ping the fully specified url. Must include https:// in the url.""" hostname = urlparse(str(url)).netloc completed_process = subprocess.run( ["ping", "-c", "1", hostname], | https://python.langchain.com/docs/guides/evaluation/trajectory/trajectory_eval |
d23bed2a30c9-2 | ["ping", "-c", "1", hostname], capture_output=True, text=True ) output = completed_process.stdout if return_error and completed_process.returncode != 0: return completed_process.stderr return output@tooldef trace_route(url: HttpUrl, return_error: bool) -> str: """Trace the route to the specified url. Must include https:// in the url.""" hostname = urlparse(str(url)).netloc completed_process = subprocess.run( ["traceroute", hostname], capture_output=True, text=True ) output = completed_process.stdout if return_error and completed_process.returncode != 0: return completed_process.stderr return outputllm = ChatOpenAI(model="gpt-3.5-turbo-0613", temperature=0)agent = initialize_agent( llm=llm, tools=[ping, trace_route], agent=AgentType.OPENAI_MULTI_FUNCTIONS, return_intermediate_steps=True, # IMPORTANT!)result = agent("What's the latency like for https://langchain.com?")Evaluate Trajectory​Pass the input, trajectory, and pass to the evaluate_agent_trajectory method.evaluation_result = evaluator.evaluate_agent_trajectory( prediction=result["output"], input=result["input"], agent_trajectory=result["intermediate_steps"],)evaluation_result["score"] Type <class 'langchain.agents.openai_functions_multi_agent.base._FunctionsAgentAction'> not serializable 1.0Configuring the Evaluation LLM​If you don't select an LLM to use for evaluation, the load_evaluator | https://python.langchain.com/docs/guides/evaluation/trajectory/trajectory_eval |
d23bed2a30c9-3 | you don't select an LLM to use for evaluation, the load_evaluator function will use gpt-4 to power the evaluation chain. You can select any chat model for the agent trajectory evaluator as below.# %pip install anthropic# ANTHROPIC_API_KEY=<YOUR ANTHROPIC API KEY>from langchain.chat_models import ChatAnthropiceval_llm = ChatAnthropic(temperature=0)evaluator = load_evaluator("trajectory", llm=eval_llm)evaluation_result = evaluator.evaluate_agent_trajectory( prediction=result["output"], input=result["input"], agent_trajectory=result["intermediate_steps"],)evaluation_result["score"] 1.0Providing List of Valid Tools​By default, the evaluator doesn't take into account the tools the agent is permitted to call. You can provide these to the evaluator via the agent_tools argument.from langchain.evaluation import load_evaluatorevaluator = load_evaluator("trajectory", agent_tools=[ping, trace_route])evaluation_result = evaluator.evaluate_agent_trajectory( prediction=result["output"], input=result["input"], agent_trajectory=result["intermediate_steps"],)evaluation_result["score"] 1.0PreviousCustom Trajectory EvaluatorNextExamplesCapturing TrajectoryEvaluate TrajectoryConfiguring the Evaluation LLMProviding List of Valid ToolsCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/trajectory/trajectory_eval |
090692635e5e-0 | Custom Trajectory Evaluator | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/trajectory/custom |
090692635e5e-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsComparison EvaluatorsTrajectory EvaluatorsCustom Trajectory EvaluatorAgent TrajectoryExamplesDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationTrajectory EvaluatorsCustom Trajectory EvaluatorCustom Trajectory EvaluatorYou can make your own custom trajectory evaluators by inheriting from the AgentTrajectoryEvaluator class and overwriting the _evaluate_agent_trajectory (and _aevaluate_agent_action) method.In this example, you will make a simple trajectory evaluator that uses an LLM to determine if any actions were unnecessary.from typing import Any, Optional, Sequence, Tuplefrom langchain.chat_models import ChatOpenAIfrom langchain.chains import LLMChainfrom langchain.schema import AgentActionfrom langchain.evaluation import AgentTrajectoryEvaluatorclass StepNecessityEvaluator(AgentTrajectoryEvaluator): """Evaluate the perplexity of a predicted string.""" def __init__(self) -> None: llm = ChatOpenAI(model="gpt-4", temperature=0.0) template = """Are any of the following steps unnecessary in answering {input}? Provide the verdict on a new line as a single "Y" for yes or "N" for no. DATA ------ Steps: {trajectory} ------ Verdict:""" self.chain = LLMChain.from_string(llm, template) def _evaluate_agent_trajectory( | https://python.langchain.com/docs/guides/evaluation/trajectory/custom |
090692635e5e-2 | template) def _evaluate_agent_trajectory( self, *, prediction: str, input: str, agent_trajectory: Sequence[Tuple[AgentAction, str]], reference: Optional[str] = None, **kwargs: Any, ) -> dict: vals = [ f"{i}: Action=[{action.tool}] returned observation = [{observation}]" for i, (action, observation) in enumerate(agent_trajectory) ] trajectory = "\n".join(vals) response = self.chain.run(dict(trajectory=trajectory, input=input), **kwargs) decision = response.split("\n")[-1].strip() score = 1 if decision == "Y" else 0 return {"score": score, "value": decision, "reasoning": response}The example above will return a score of 1 if the language model predicts that any of the actions were unnecessary, and it returns a score of 0 if all of them were predicted to be necessary.You can call this evaluator to grade the intermediate steps of your agent's trajectory.evaluator = StepNecessityEvaluator()evaluator.evaluate_agent_trajectory( prediction="The answer is pi", input="What is today?", agent_trajectory=[ ( AgentAction(tool="ask", tool_input="What is | https://python.langchain.com/docs/guides/evaluation/trajectory/custom |
090692635e5e-3 | AgentAction(tool="ask", tool_input="What is today?", log=""), "tomorrow's yesterday", ), ( AgentAction(tool="check_tv", tool_input="Watch tv for half hour", log=""), "bzzz", ), ],) {'score': 1, 'value': 'Y', 'reasoning': 'Y'}PreviousTrajectory EvaluatorsNextAgent TrajectoryCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/trajectory/custom |
cc868abf9b0f-0 | Comparison Evaluators | 🦜�🔗 Langchain
Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsComparison EvaluatorsCustom Pairwise EvaluatorPairwise Embedding DistancePairwise String ComparisonTrajectory EvaluatorsExamplesDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationComparison EvaluatorsComparison Evaluators📄� Custom Pairwise EvaluatorYou can make your own pairwise string evaluators by inheriting from PairwiseStringEvaluator class and overwriting the evaluatestringpairs method (and the aevaluatestringpairs method if you want to use the evaluator asynchronously).📄� Pairwise Embedding DistanceOne way to measure the similarity (or dissimilarity) between two predictions on a shared or similar input is to embed the predictions and compute a vector distance between the two embeddings.[1]📄� Pairwise String ComparisonOften you will want to compare predictions of an LLM, Chain, or Agent for a given input. The StringComparison evaluators facilitate this so you can answer questions like:PreviousString DistanceNextCustom Pairwise EvaluatorCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/comparison/ |
c4ed184747cf-0 | Custom Pairwise Evaluator | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/comparison/custom |
c4ed184747cf-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsComparison EvaluatorsCustom Pairwise EvaluatorPairwise Embedding DistancePairwise String ComparisonTrajectory EvaluatorsExamplesDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationComparison EvaluatorsCustom Pairwise EvaluatorOn this pageCustom Pairwise EvaluatorYou can make your own pairwise string evaluators by inheriting from PairwiseStringEvaluator class and overwriting the _evaluate_string_pairs method (and the _aevaluate_string_pairs method if you want to use the evaluator asynchronously).In this example, you will make a simple custom evaluator that just returns whether the first prediction has more whitespace tokenized 'words' than the second.You can check out the reference docs for the PairwiseStringEvaluator interface for more info.from typing import Optional, Anyfrom langchain.evaluation import PairwiseStringEvaluatorclass LengthComparisonPairwiseEvalutor(PairwiseStringEvaluator): """ Custom evaluator to compare two strings. """ def _evaluate_string_pairs( self, *, prediction: str, prediction_b: str, reference: Optional[str] = None, input: Optional[str] = None, **kwargs: Any, ) -> dict: score = int(len(prediction.split()) > len(prediction_b.split())) return {"score": score}evaluator = | https://python.langchain.com/docs/guides/evaluation/comparison/custom |
c4ed184747cf-2 | return {"score": score}evaluator = LengthComparisonPairwiseEvalutor()evaluator.evaluate_string_pairs( prediction="The quick brown fox jumped over the lazy dog.", prediction_b="The quick brown fox jumped over the dog.",) {'score': 1}LLM-Based Example​That example was simple to illustrate the API, but it wasn't very useful in practice. Below, use an LLM with some custom instructions to form a simple preference scorer similar to the built-in PairwiseStringEvalChain. We will use ChatAnthropic for the evaluator chain.# %pip install anthropic# %env ANTHROPIC_API_KEY=YOUR_API_KEYfrom typing import Optional, Anyfrom langchain.evaluation import PairwiseStringEvaluatorfrom langchain.chat_models import ChatAnthropicfrom langchain.chains import LLMChainclass CustomPreferenceEvaluator(PairwiseStringEvaluator): """ Custom evaluator to compare two strings using a custom LLMChain. """ def __init__(self) -> None: llm = ChatAnthropic(model="claude-2", temperature=0) self.eval_chain = LLMChain.from_string( llm, """Which option is preferred? Do not take order into account. Evaluate based on accuracy and helpfulness. If neither is preferred, respond with C. Provide your reasoning, then finish with Preference: A/B/CInput: How do I get the path of the parent directory in python 3.8?Option A: You can use the following code:```pythonimport osos.path.dirname(os.path.dirname(os.path.abspath(__file__)))Option B: You can use the following code:from pathlib import | https://python.langchain.com/docs/guides/evaluation/comparison/custom |
c4ed184747cf-3 | B: You can use the following code:from pathlib import PathPath(__file__).absolute().parentReasoning: Both options return the same result. However, since option B is more concise and easily understand, it is preferred. | https://python.langchain.com/docs/guides/evaluation/comparison/custom |
c4ed184747cf-4 | Preference: BWhich option is preferred? Do not take order into account. Evaluate based on accuracy and helpfulness. If neither is preferred, respond with C. Provide your reasoning, then finish with Preference: A/B/C
Input: {input}
Option A: {prediction}
Option B: {prediction_b}
Reasoning:""", | https://python.langchain.com/docs/guides/evaluation/comparison/custom |
c4ed184747cf-5 | )@propertydef requires_input(self) -> bool: return True@propertydef requires_reference(self) -> bool: return Falsedef _evaluate_string_pairs( self, *, prediction: str, prediction_b: str, reference: Optional[str] = None, input: Optional[str] = None, **kwargs: Any,) -> dict: result = self.eval_chain( { "input": input, "prediction": prediction, "prediction_b": prediction_b, "stop": ["Which option is preferred?"], }, **kwargs, ) response_text = result["text"] reasoning, preference = response_text.split("Preference:", maxsplit=1) preference = preference.strip() score = 1.0 if preference == "A" else (0.0 if preference == "B" else None) return {"reasoning": reasoning.strip(), "value": preference, "score": score}```pythonevaluator = CustomPreferenceEvaluator()evaluator.evaluate_string_pairs( input="How do I import from a relative directory?", prediction="use importlib! importlib.import_module('.my_package', '.')", prediction_b="from .sibling import foo",) {'reasoning': 'Option B is preferred over option A for importing from a relative directory, because it is more straightforward and concise.\n\nOption A uses the importlib module, which allows importing a module by | https://python.langchain.com/docs/guides/evaluation/comparison/custom |
c4ed184747cf-6 | straightforward and concise.\n\nOption A uses the importlib module, which allows importing a module by specifying the full name as a string. While this works, it is less clear compared to option B.\n\nOption B directly imports from the relative path using dot notation, which clearly shows that it is a relative import. This is the recommended way to do relative imports in Python.\n\nIn summary, option B is more accurate and helpful as it uses the standard Python relative import syntax.', 'value': 'B', 'score': 0.0}# Setting requires_input to return True adds additional validation to avoid returning a grade when insufficient data is provided to the chain.try: evaluator.evaluate_string_pairs( prediction="use importlib! importlib.import_module('.my_package', '.')", prediction_b="from .sibling import foo", )except ValueError as e: print(e) CustomPreferenceEvaluator requires an input string.PreviousComparison EvaluatorsNextPairwise Embedding DistanceLLM-Based ExampleCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/comparison/custom |
ac3ff691981a-0 | Pairwise Embedding Distance | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/comparison/pairwise_embedding_distance |
ac3ff691981a-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsComparison EvaluatorsCustom Pairwise EvaluatorPairwise Embedding DistancePairwise String ComparisonTrajectory EvaluatorsExamplesDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationComparison EvaluatorsPairwise Embedding DistanceOn this pagePairwise Embedding DistanceOne way to measure the similarity (or dissimilarity) between two predictions on a shared or similar input is to embed the predictions and compute a vector distance between the two embeddings.[1]You can load the pairwise_embedding_distance evaluator to do this.Note: This returns a distance score, meaning that the lower the number, the more similar the outputs are, according to their embedded representation.Check out the reference docs for the PairwiseEmbeddingDistanceEvalChain for more info.from langchain.evaluation import load_evaluatorevaluator = load_evaluator("pairwise_embedding_distance")evaluator.evaluate_string_pairs( prediction="Seattle is hot in June", prediction_b="Seattle is cool in June.") {'score': 0.0966466944859925}evaluator.evaluate_string_pairs( prediction="Seattle is warm in June", prediction_b="Seattle is cool in June.") {'score': 0.03761174337464557}Select the Distance Metric​By default, the evalutor uses cosine distance. You can choose a different distance metric if you'd like. from langchain.evaluation import EmbeddingDistancelist(EmbeddingDistance) [<EmbeddingDistance.COSINE: 'cosine'>, <EmbeddingDistance.EUCLIDEAN: 'euclidean'>, | https://python.langchain.com/docs/guides/evaluation/comparison/pairwise_embedding_distance |
ac3ff691981a-2 | <EmbeddingDistance.EUCLIDEAN: 'euclidean'>, <EmbeddingDistance.MANHATTAN: 'manhattan'>, <EmbeddingDistance.CHEBYSHEV: 'chebyshev'>, <EmbeddingDistance.HAMMING: 'hamming'>]evaluator = load_evaluator( "pairwise_embedding_distance", distance_metric=EmbeddingDistance.EUCLIDEAN)Select Embeddings to Use​The constructor uses OpenAI embeddings by default, but you can configure this however you want. Below, use huggingface local embeddingsfrom langchain.embeddings import HuggingFaceEmbeddingsembedding_model = HuggingFaceEmbeddings()hf_evaluator = load_evaluator("pairwise_embedding_distance", embeddings=embedding_model)hf_evaluator.evaluate_string_pairs( prediction="Seattle is hot in June", prediction_b="Seattle is cool in June.") {'score': 0.5486443280477362}hf_evaluator.evaluate_string_pairs( prediction="Seattle is warm in June", prediction_b="Seattle is cool in June.") {'score': 0.21018880025138598}1. Note: When it comes to semantic similarity, this often gives better results than older string distance metrics (such as those in the `PairwiseStringDistanceEvalChain`), though it tends to be less reliable than evaluators that use the LLM directly (such as the `PairwiseStringEvalChain`) PreviousCustom Pairwise EvaluatorNextPairwise String ComparisonSelect the Distance MetricSelect Embeddings to UseCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/comparison/pairwise_embedding_distance |
a857ded138da-0 | Pairwise String Comparison | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/evaluation/comparison/pairwise_string |
a857ded138da-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationString EvaluatorsComparison EvaluatorsCustom Pairwise EvaluatorPairwise Embedding DistancePairwise String ComparisonTrajectory EvaluatorsExamplesDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesEvaluationComparison EvaluatorsPairwise String ComparisonOn this pagePairwise String ComparisonOften you will want to compare predictions of an LLM, Chain, or Agent for a given input. The StringComparison evaluators facilitate this so you can answer questions like:Which LLM or prompt produces a preferred output for a given question?Which examples should I include for few-shot example selection?Which output is better to include for fintetuning?The simplest and often most reliable automated way to choose a preferred prediction for a given input is to use the pairwise_string evaluator.Check out the reference docs for the PairwiseStringEvalChain for more info.from langchain.evaluation import load_evaluatorevaluator = load_evaluator("pairwise_string", requires_reference=True)evaluator.evaluate_string_pairs( prediction="there are three dogs", prediction_b="4", input="how many dogs are in the park?", reference="four",) {'reasoning': 'Response A provides an incorrect answer by stating there are three dogs in the park, while the reference answer indicates there are four. Response B, on the other hand, provides the correct answer, matching the reference answer. Although Response B is less detailed, it is accurate and directly answers the question. \n\nTherefore, the better response is [[B]].\n', 'value': 'B', 'score': 0}Without References​When references aren't available, you can still predict the preferred response. | https://python.langchain.com/docs/guides/evaluation/comparison/pairwise_string |
a857ded138da-2 | The results will reflect the evaluation model's preference, which is less reliable and may result | https://python.langchain.com/docs/guides/evaluation/comparison/pairwise_string |
a857ded138da-3 | in preferences that are factually incorrect.from langchain.evaluation import load_evaluatorevaluator = load_evaluator("pairwise_string")evaluator.evaluate_string_pairs( prediction="Addition is a mathematical operation.", prediction_b="Addition is a mathematical operation that adds two numbers to create a third number, the 'sum'.", input="What is addition?",) {'reasoning': "Response A is accurate but lacks depth and detail. It simply states that addition is a mathematical operation without explaining what it does or how it works. \n\nResponse B, on the other hand, provides a more detailed explanation. It not only identifies addition as a mathematical operation, but also explains that it involves adding two numbers to create a third number, the 'sum'. This response is more helpful and informative, providing a clearer understanding of what addition is.\n\nTherefore, the better response is B.\n", 'value': 'B', 'score': 0}Customize the LLM​By default, the loader uses gpt-4 in the evaluation chain. You can customize this when loading.from langchain.chat_models import ChatAnthropicllm = ChatAnthropic(temperature=0)evaluator = load_evaluator("pairwise_string", llm=llm, requires_reference=True)evaluator.evaluate_string_pairs( prediction="there are three dogs", prediction_b="4", input="how many dogs are in the park?", reference="four",) {'reasoning': 'Response A provides a specific number but is inaccurate based on the reference answer. Response B provides the correct number but lacks detail or explanation. Overall, Response B is more helpful and accurate in directly answering the question, despite lacking depth or creativity.\n\n[[B]]\n', | https://python.langchain.com/docs/guides/evaluation/comparison/pairwise_string |
a857ded138da-4 | question, despite lacking depth or creativity.\n\n[[B]]\n', 'value': 'B', 'score': 0}Customize the Evaluation Prompt​You can use your own custom evaluation prompt to add more task-specific instructions or to instruct the evaluator to score the output.*Note: If you use a prompt that expects generates a result in a unique format, you may also have to pass in a custom output parser (output_parser=your_parser()) instead of the default PairwiseStringResultOutputParserfrom langchain.prompts import PromptTemplateprompt_template = PromptTemplate.from_template( """Given the input context, which is most similar to the reference label: A or B?Reason step by step and finally, respond with either [[A]] or [[B]] on its own line.DATA----input: {input}reference: {reference}A: {prediction}B: {prediction_b}---Reasoning:""")evaluator = load_evaluator( "pairwise_string", prompt=prompt_template, requires_reference=True)# The prompt was assigned to the evaluatorprint(evaluator.prompt) input_variables=['input', 'prediction', 'prediction_b', 'reference'] output_parser=None partial_variables={} template='Given the input context, which is most similar to the reference label: A or B?\nReason step by step and finally, respond with either [[A]] or [[B]] on its own line.\n\nDATA\n----\ninput: {input}\nreference: {reference}\nA: {prediction}\nB: {prediction_b}\n---\nReasoning:\n\n' template_format='f-string' validate_template=Trueevaluator.evaluate_string_pairs( prediction="The dog that ate the ice cream was named fido.", prediction_b="The dog's name is spot", input="What is the name | https://python.langchain.com/docs/guides/evaluation/comparison/pairwise_string |
a857ded138da-5 | prediction_b="The dog's name is spot", input="What is the name of the dog that ate the ice cream?", reference="The dog's name is fido",) {'reasoning': "Option A is most similar to the reference label. Both the reference label and option A state that the dog's name is Fido. Option B, on the other hand, gives a different name for the dog. Therefore, option A is the most similar to the reference label. \n", 'value': 'A', 'score': 1}PreviousPairwise Embedding DistanceNextTrajectory EvaluatorsWithout ReferencesCustomize the LLMCustomize the Evaluation PromptCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/evaluation/comparison/pairwise_string |
016228b75473-0 | Model Comparison | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/model_laboratory |
016228b75473-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationDebuggingDeploymentLangSmithModel ComparisonEcosystemAdditional resourcesGuidesModel ComparisonModel ComparisonConstructing your language model application will likely involved choosing between many different options of prompts, models, and even chains to use. When doing so, you will want to compare these different options on different inputs in an easy, flexible, and intuitive way. LangChain provides the concept of a ModelLaboratory to test out and try different models.from langchain import LLMChain, OpenAI, Cohere, HuggingFaceHub, PromptTemplatefrom langchain.model_laboratory import ModelLaboratoryllms = [ OpenAI(temperature=0), Cohere(model="command-xlarge-20221108", max_tokens=20, temperature=0), HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 1}),]model_lab = ModelLaboratory.from_llms(llms)model_lab.compare("What color is a flamingo?") Input: What color is a flamingo? OpenAI Params: {'model': 'text-davinci-002', 'temperature': 0.0, 'max_tokens': 256, 'top_p': 1, 'frequency_penalty': 0, 'presence_penalty': 0, 'n': 1, 'best_of': 1} Flamingos are pink. Cohere Params: {'model': 'command-xlarge-20221108', | https://python.langchain.com/docs/guides/model_laboratory |
016228b75473-2 | Cohere Params: {'model': 'command-xlarge-20221108', 'max_tokens': 20, 'temperature': 0.0, 'k': 0, 'p': 1, 'frequency_penalty': 0, 'presence_penalty': 0} Pink HuggingFaceHub Params: {'repo_id': 'google/flan-t5-xl', 'temperature': 1} pink prompt = PromptTemplate( template="What is the capital of {state}?", input_variables=["state"])model_lab_with_prompt = ModelLaboratory.from_llms(llms, prompt=prompt)model_lab_with_prompt.compare("New York") Input: New York OpenAI Params: {'model': 'text-davinci-002', 'temperature': 0.0, 'max_tokens': 256, 'top_p': 1, 'frequency_penalty': 0, 'presence_penalty': 0, 'n': 1, 'best_of': 1} The capital of New York is Albany. Cohere Params: {'model': 'command-xlarge-20221108', 'max_tokens': 20, 'temperature': 0.0, 'k': 0, 'p': 1, 'frequency_penalty': 0, 'presence_penalty': 0} The capital of New York is Albany. HuggingFaceHub Params: {'repo_id': 'google/flan-t5-xl', 'temperature': 1} st john s from langchain | https://python.langchain.com/docs/guides/model_laboratory |
016228b75473-3 | 'temperature': 1} st john s from langchain import SelfAskWithSearchChain, SerpAPIWrapperopen_ai_llm = OpenAI(temperature=0)search = SerpAPIWrapper()self_ask_with_search_openai = SelfAskWithSearchChain( llm=open_ai_llm, search_chain=search, verbose=True)cohere_llm = Cohere(temperature=0, model="command-xlarge-20221108")search = SerpAPIWrapper()self_ask_with_search_cohere = SelfAskWithSearchChain( llm=cohere_llm, search_chain=search, verbose=True)chains = [self_ask_with_search_openai, self_ask_with_search_cohere]names = [str(open_ai_llm), str(cohere_llm)]model_lab = ModelLaboratory(chains, names=names)model_lab.compare("What is the hometown of the reigning men's U.S. Open champion?") Input: What is the hometown of the reigning men's U.S. Open champion? OpenAI Params: {'model': 'text-davinci-002', 'temperature': 0.0, 'max_tokens': 256, 'top_p': 1, 'frequency_penalty': 0, 'presence_penalty': 0, 'n': 1, 'best_of': 1} > Entering new chain... What is the hometown of the reigning men's U.S. Open champion? Are follow up questions needed here: Yes. Follow up: Who is the reigning men's U.S. Open champion? Intermediate answer: Carlos Alcaraz. Follow up: Where is Carlos Alcaraz from? Intermediate answer: El | https://python.langchain.com/docs/guides/model_laboratory |
016228b75473-4 | Follow up: Where is Carlos Alcaraz from? Intermediate answer: El Palmar, Spain. So the final answer is: El Palmar, Spain > Finished chain. So the final answer is: El Palmar, Spain Cohere Params: {'model': 'command-xlarge-20221108', 'max_tokens': 256, 'temperature': 0.0, 'k': 0, 'p': 1, 'frequency_penalty': 0, 'presence_penalty': 0} > Entering new chain... What is the hometown of the reigning men's U.S. Open champion? Are follow up questions needed here: Yes. Follow up: Who is the reigning men's U.S. Open champion? Intermediate answer: Carlos Alcaraz. So the final answer is: Carlos Alcaraz > Finished chain. So the final answer is: Carlos Alcaraz PreviousLangSmith WalkthroughNextEcosystemCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/model_laboratory |
385697ef0e6a-0 | LangSmith | 🦜�🔗 Langchain
Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationDebuggingDeploymentLangSmithLangSmith WalkthroughModel ComparisonEcosystemAdditional resourcesGuidesLangSmithLangSmithLangSmith helps you trace and evaluate your language model applications and intelligent agents to help you
move from prototype to production.Check out the interactive walkthrough below to get started.For more information, please refer to the LangSmith documentation📄� LangSmith WalkthroughLangChain makes it easy to prototype LLM applications and Agents. However, delivering LLM applications to production can be deceptively difficult. You will likely have to heavily customize and iterate on your prompts, chains, and other components to create a high-quality product.PreviousTemplate reposNextLangSmith WalkthroughCommunityDiscordTwitterGitHubPythonJS/TSMoreHomepageBlogCopyright © 2023 LangChain, Inc. | https://python.langchain.com/docs/guides/langsmith/ |
712506381261-0 | LangSmith Walkthrough | 🦜�🔗 Langchain | https://python.langchain.com/docs/guides/langsmith/walkthrough |
712506381261-1 | Skip to main content🦜�🔗 LangChainDocsUse casesIntegrationsAPILangSmithJS/TS DocsCTRLKGet startedIntroductionInstallationQuickstartModulesModel I/​OData connectionChainsMemoryAgentsCallbacksModulesGuidesEvaluationDebuggingDeploymentLangSmithLangSmith WalkthroughModel ComparisonEcosystemAdditional resourcesGuidesLangSmithLangSmith WalkthroughOn this pageLangSmith WalkthroughLangChain makes it easy to prototype LLM applications and Agents. However, delivering LLM applications to production can be deceptively difficult. You will likely have to heavily customize and iterate on your prompts, chains, and other components to create a high-quality product.To aid in this process, we've launched LangSmith, a unified platform for debugging, testing, and monitoring your LLM applications.When might this come in handy? You may find it useful when you want to:Quickly debug a new chain, agent, or set of toolsVisualize how components (chains, llms, retrievers, etc.) relate and are usedEvaluate different prompts and LLMs for a single componentRun a given chain several times over a dataset to ensure it consistently meets a quality barCapture usage traces and using LLMs or analytics pipelines to generate insightsPrerequisites​Create a LangSmith account and create an API key (see bottom left corner). Familiarize yourself with the platform by looking through the docsNote LangSmith is in closed beta; we're in the process of rolling it out to more users. However, you can fill out the form on the website for expedited access.Now, let's get started!Log runs to LangSmith​First, configure your environment variables to tell LangChain to log traces. This is done by setting the LANGCHAIN_TRACING_V2 environment variable to true. | https://python.langchain.com/docs/guides/langsmith/walkthrough |
712506381261-2 | You can tell LangChain which project to log to by setting the LANGCHAIN_PROJECT environment variable (if this isn't set, runs will be logged to the default project). This will automatically create the project for you if it doesn't exist. You must also set the LANGCHAIN_ENDPOINT and LANGCHAIN_API_KEY environment variables.For more information on other ways to set up tracing, please reference the LangSmith documentationNOTE: You must also set your OPENAI_API_KEY and SERPAPI_API_KEY environment variables in order to run the following tutorial.NOTE: You can only access an API key when you first create it. Keep it somewhere safe.NOTE: You can also use a context manager in python to log traces usingfrom langchain.callbacks.manager import tracing_v2_enabledwith tracing_v2_enabled(project_name="My Project"): agent.run("How many people live in canada as of 2023?")However, in this example, we will use environment variables.import osfrom uuid import uuid4unique_id = uuid4().hex[0:8]os.environ["LANGCHAIN_TRACING_V2"] = "true"os.environ["LANGCHAIN_PROJECT"] = f"Tracing Walkthrough - {unique_id}"os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"os.environ["LANGCHAIN_API_KEY"] = "" # Update to your API key# Used by the agent in this tutorial# os.environ["OPENAI_API_KEY"] = "<YOUR-OPENAI-API-KEY>"# os.environ["SERPAPI_API_KEY"] = "<YOUR-SERPAPI-API-KEY>"Create the langsmith client to interact with the APIfrom langsmith import Clientclient = Client()Create a LangChain component and log runs to the platform. In this example, we will create a ReAct-style agent with access to Search and Calculator as tools. However, LangSmith works regardless of which type of LangChain component you use (LLMs, Chat Models, | https://python.langchain.com/docs/guides/langsmith/walkthrough |
712506381261-3 | LangSmith works regardless of which type of LangChain component you use (LLMs, Chat Models, Tools, Retrievers, Agents are all supported).from langchain.chat_models import ChatOpenAIfrom langchain.agents import AgentType, initialize_agent, load_toolsllm = ChatOpenAI(temperature=0)tools = load_tools(["serpapi", "llm-math"], llm=llm)agent = initialize_agent( tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=False)We are running the agent concurrently on multiple inputs to reduce latency. Runs get logged to LangSmith in the background so execution latency is unaffected.import asyncioinputs = [ "How many people live in canada as of 2023?", "who is dua lipa's boyfriend? what is his age raised to the .43 power?", "what is dua lipa's boyfriend age raised to the .43 power?", "how far is it from paris to boston in miles", "what was the total number of points scored in the 2023 super bowl? what is that number raised to the .23 power?", "what was the total number of points scored in the 2023 super bowl raised to the .23 power?", "how many more points were scored in the 2023 super bowl than in the 2022 super bowl?", "what is 153 raised to .1312 power?", "who is kendall jenner's boyfriend? what is his height (in inches) raised to .13 power?", "what is 1213 divided by 4345?",]results = []async def arun(agent, input_example): try: return await agent.arun(input_example) except Exception as e: | https://python.langchain.com/docs/guides/langsmith/walkthrough |
712506381261-4 | return await agent.arun(input_example) except Exception as e: # The agent sometimes makes mistakes! These will be captured by the tracing. return efor input_example in inputs: results.append(arun(agent, input_example))results = await asyncio.gather(*results)from langchain.callbacks.tracers.langchain import wait_for_all_tracers# Logs are submitted in a background thread to avoid blocking execution.# For the sake of this tutorial, we want to make sure# they've been submitted before moving on. This is also# useful for serverless deployments.wait_for_all_tracers()Assuming you've successfully set up your environment, your agent traces should show up in the Projects section in the app. Congrats!Evaluate another agent implementation​In addition to logging runs, LangSmith also allows you to test and evaluate your LLM applications.In this section, you will leverage LangSmith to create a benchmark dataset and run AI-assisted evaluators on an agent. You will do so in a few steps:Create a dataset from pre-existing run inputs and outputsInitialize a new agent to benchmarkConfigure evaluators to grade an agent's outputRun the agent over the dataset and evaluate the results1. Create a LangSmith dataset​Below, we use the LangSmith client to create a dataset from the agent runs you just logged above. You will use these later to measure performance for a new agent. This is simply taking the inputs and outputs of the runs and saving them as examples to a dataset. A dataset is a collection of examples, which are nothing more than input-output pairs you can use as test cases to your application.Note: this is a simple, walkthrough example. In a real-world setting, you'd ideally first validate the outputs before adding them to a benchmark dataset to be used for evaluating other agents.For more information on datasets, including how to | https://python.langchain.com/docs/guides/langsmith/walkthrough |
712506381261-5 | to a benchmark dataset to be used for evaluating other agents.For more information on datasets, including how to create them from CSVs or other files or how to create them in the platform, please refer to the LangSmith documentation.dataset_name = f"calculator-example-dataset-{unique_id}"dataset = client.create_dataset( dataset_name, description="A calculator example dataset")runs = client.list_runs( project_name=os.environ["LANGCHAIN_PROJECT"], execution_order=1, # Only return the top-level runs error=False, # Only runs that succeed)for run in runs: client.create_example(inputs=run.inputs, outputs=run.outputs, dataset_id=dataset.id)2. Initialize a new agent to benchmark​You can evaluate any LLM, chain, or agent. Since chains can have memory, we will pass in a chain_factory (aka a constructor ) function to initialize for each call.In this case, we will test an agent that uses OpenAI's function calling endpoints.from langchain.chat_models import ChatOpenAIfrom langchain.agents import AgentType, initialize_agent, load_toolsllm = ChatOpenAI(model="gpt-3.5-turbo-0613", temperature=0)tools = load_tools(["serpapi", "llm-math"], llm=llm)# Since chains can be stateful (e.g. they can have memory), we provide# a way to initialize a new chain for each row in the dataset. This is done# by passing in a factory function that returns a new chain for each row.def agent_factory(): return initialize_agent(tools, llm, agent=AgentType.OPENAI_FUNCTIONS, verbose=False)# If your chain is NOT stateful, your factory can return the object directly# to improve runtime performance. For example:# chain_factory = lambda: agent3. Configure | https://python.langchain.com/docs/guides/langsmith/walkthrough |
712506381261-6 | object directly# to improve runtime performance. For example:# chain_factory = lambda: agent3. Configure evaluation​Manually comparing the results of chains in the UI is effective, but it can be time consuming. | https://python.langchain.com/docs/guides/langsmith/walkthrough |
712506381261-7 | It can be helpful to use automated metrics and AI-assisted feedback to evaluate your component's performance.Below, we will create some pre-implemented run evaluators that do the following:Compare results against ground truth labels. (You used the debug outputs above for this)Measure semantic (dis)similarity using embedding distanceEvaluate 'aspects' of the agent's response in a reference-free manner using custom criteriaFor a longer discussion of how to select an appropriate evaluator for your use case and how to create your own | https://python.langchain.com/docs/guides/langsmith/walkthrough |
712506381261-8 | custom evaluators, please refer to the LangSmith documentation.from langchain.evaluation import EvaluatorTypefrom langchain.smith import RunEvalConfigevaluation_config = RunEvalConfig( # Evaluators can either be an evaluator type (e.g., "qa", "criteria", "embedding_distance", etc.) or a configuration for that evaluator evaluators=[ # Measures whether a QA response is "Correct", based on a reference answer # You can also select via the raw string "qa" EvaluatorType.QA, # Measure the embedding distance between the output and the reference answer # Equivalent to: EvalConfig.EmbeddingDistance(embeddings=OpenAIEmbeddings()) EvaluatorType.EMBEDDING_DISTANCE, # Grade whether the output satisfies the stated criteria. You can select a default one such as "helpfulness" or provide your own. RunEvalConfig.LabeledCriteria("helpfulness"), # Both the Criteria and LabeledCriteria evaluators can be configured with a dictionary of custom criteria. RunEvalConfig.Criteria( { "fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?" } ), ], # You can add custom StringEvaluator or RunEvaluator objects here as well, which will automatically be # applied to each prediction. Check out the docs for examples. | https://python.langchain.com/docs/guides/langsmith/walkthrough |
712506381261-9 | be # applied to each prediction. Check out the docs for examples. custom_evaluators=[],)4. Run the agent and evaluators​Use the arun_on_dataset (or synchronous run_on_dataset) function to evaluate your model. This will:Fetch example rows from the specified datasetRun your llm or chain on each example.Apply evalutors to the resulting run traces and corresponding reference examples to generate automated feedback.The results will be visible in the LangSmith app.from langchain.smith import ( arun_on_dataset, run_on_dataset, # Available if your chain doesn't support async calls.)chain_results = await arun_on_dataset( client=client, dataset_name=dataset_name, llm_or_chain_factory=agent_factory, evaluation=evaluation_config, verbose=True, tags=["testing-notebook"], # Optional, adds a tag to the resulting chain runs)# Sometimes, the agent will error due to parsing issues, incompatible tool inputs, etc.# These are logged as warnings here and captured as errors in the tracing UI. View the evaluation results for project '2023-07-17-11-25-20-AgentExecutor' at: https://dev.smith.langchain.com/projects/p/1c9baec3-ae86-4fac-9e99-e1b9f8e7818c?eval=true Processed examples: 1 Chain failed for example 5a2ac8da-8c2b-4d12-acb9-5c4b0f47fe8a. Error: LLMMathChain._evaluate(" age_of_Dua_Lipa_boyfriend ** 0.43 ") raised error: | https://python.langchain.com/docs/guides/langsmith/walkthrough |
712506381261-10 | ** 0.43 ") raised error: 'age_of_Dua_Lipa_boyfriend'. Please try again with a valid numerical expression Processed examples: 4 Chain failed for example 91439261-1c86-4198-868b-a6c1cc8a051b. Error: Too many arguments to single-input tool Calculator. Args: ['height ^ 0.13', {'height': 68}] Processed examples: 9Review the test results​You can review the test results tracing UI below by navigating to the "Datasets & Testing" page and selecting the "calculator-example-dataset-*" dataset, clicking on the Test Runs tab, then inspecting the runs in the corresponding project. This will show the new runs and the feedback logged from the selected evaluators. Note that runs that error out will not have feedback.Exporting datasets and runs​LangSmith lets you export data to common formats such as CSV or JSONL directly in the web app. You can also use the client to fetch runs for further analysis, to store in your own database, or to share with others. Let's fetch the run traces from the evaluation run.runs = list(client.list_runs(dataset_name=dataset_name))runs[0] Run(id=UUID('e39f310b-c5a8-4192-8a59-6a9498e1cb85'), name='AgentExecutor', start_time=datetime.datetime(2023, 7, 17, 18, 25, 30, 653872), run_type=<RunTypeEnum.chain: 'chain'>, end_time=datetime.datetime(2023, 7, 17, 18, 25, 35, 359642), extra={'runtime': {'library': 'langchain', 'runtime': 'python', 'platform': | https://python.langchain.com/docs/guides/langsmith/walkthrough |
712506381261-11 | extra={'runtime': {'library': 'langchain', 'runtime': 'python', 'platform': 'macOS-13.4.1-arm64-arm-64bit', 'sdk_version': '0.0.8', 'library_version': '0.0.231', 'runtime_version': '3.11.2'}, 'total_tokens': 512, 'prompt_tokens': 451, 'completion_tokens': 61}, error=None, serialized=None, events=[{'name': 'start', 'time': '2023-07-17T18:25:30.653872'}, {'name': 'end', 'time': '2023-07-17T18:25:35.359642'}], inputs={'input': 'what is 1213 divided by 4345?'}, outputs={'output': '1213 divided by 4345 is approximately 0.2792.'}, reference_example_id=UUID('a75cf754-4f73-46fd-b126-9bcd0695e463'), parent_run_id=None, tags=['openai-functions', 'testing-notebook'], execution_order=1, session_id=UUID('1c9baec3-ae86-4fac-9e99-e1b9f8e7818c'), child_run_ids=[UUID('40d0fdca-0b2b-47f4-a9da-f2b229aa4ed5'), UUID('cfa5130f-264c-4126-8950-ec1c4c31b800'), UUID('ba638a2f-2a57-45db-91e8-9a7a66a42c5a'), UUID('fcc29b5a-cdb7-4bcc-8194-47729bbdf5fb'), | https://python.langchain.com/docs/guides/langsmith/walkthrough |
712506381261-12 | UUID('a6f92bf5-cfba-4747-9336-370cb00c928a'), UUID('65312576-5a39-4250-b820-4dfae7d73945')], child_runs=None, feedback_stats={'correctness': {'n': 1, 'avg': 1.0, 'mode': 1}, 'helpfulness': {'n': 1, 'avg': 1.0, 'mode': 1}, 'fifth-grader-score': {'n': 1, 'avg': 1.0, 'mode': 1}, 'embedding_cosine_distance': {'n': 1, 'avg': 0.144522385071361, 'mode': 0.144522385071361}})client.read_project(project_id=runs[0].session_id).feedback_stats {'correctness': {'n': 7, 'avg': 0.5714285714285714, 'mode': 1}, 'helpfulness': {'n': 7, 'avg': 0.7142857142857143, 'mode': 1}, 'fifth-grader-score': {'n': 7, 'avg': 0.7142857142857143, 'mode': 1}, 'embedding_cosine_distance': {'n': 7, 'avg': 0.11462010799473926, 'mode': 0.0130477459560272}}Conclusion​Congratulations! You have succesfully traced and evaluated an agent using LangSmith!This was a quick guide to get started, but there are many more ways to use LangSmith to speed up your developer flow and produce better results.For more information on how you can get the most out of LangSmith, check out | https://python.langchain.com/docs/guides/langsmith/walkthrough |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.