langchain 0.3.27__py3-none-any.whl → 1.0.0__py3-none-any.whl

langchain/evaluation/qa/eval_chain.py

@@ -1,364 +0,0 @@
-"""LLM Chains for evaluating question answering."""
-
-from __future__ import annotations
-
-import re
-import string
-from collections.abc import Sequence
-from typing import Any, Optional
-
-from langchain_core.callbacks import Callbacks
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.prompts import PromptTemplate
-from pydantic import ConfigDict
-from typing_extensions import override
-
-from langchain.chains.llm import LLMChain
-from langchain.evaluation.qa.eval_prompt import CONTEXT_PROMPT, COT_PROMPT, PROMPT
-from langchain.evaluation.schema import LLMEvalChain, StringEvaluator
-from langchain.schema import RUN_KEY
-
-
-def _get_score(text: str) -> Optional[tuple[str, int]]:
-    match = re.search(r"grade:\s*(correct|incorrect)", text.strip(), re.IGNORECASE)
-    if match:
-        if match.group(1).upper() == "CORRECT":
-            return "CORRECT", 1
-        if match.group(1).upper() == "INCORRECT":
-            return "INCORRECT", 0
-    try:
-        first_word = (
-            text.strip().split()[0].translate(str.maketrans("", "", string.punctuation))
-        )
-        if first_word.upper() == "CORRECT":
-            return "CORRECT", 1
-        if first_word.upper() == "INCORRECT":
-            return "INCORRECT", 0
-        last_word = (
-            text.strip()
-            .split()[-1]
-            .translate(str.maketrans("", "", string.punctuation))
-        )
-        if last_word.upper() == "CORRECT":
-            return "CORRECT", 1
-        if last_word.upper() == "INCORRECT":
-            return "INCORRECT", 0
-    except IndexError:
-        pass
-    return None
-
-
-def _parse_string_eval_output(text: str) -> dict:
-    """Parse the output text.
-
-    Args:
-        text (str): The output text to parse.
-
-    Returns:
-        Any: The parsed output.
-    """
-    reasoning = text.strip()
-    parsed_scores = _get_score(reasoning)
-    if parsed_scores is None:
-        value, score = None, None
-    else:
-        value, score = parsed_scores
-    return {
-        "reasoning": reasoning,
-        "value": value,
-        "score": score,
-    }
-
-
-class QAEvalChain(LLMChain, StringEvaluator, LLMEvalChain):
-    """LLM Chain for evaluating question answering."""
-
-    output_key: str = "results"  #: :meta private:
-
-    model_config = ConfigDict(
-        extra="ignore",
-    )
-
-    @classmethod
-    def is_lc_serializable(cls) -> bool:
-        return False
-
-    @property
-    def evaluation_name(self) -> str:
-        return "correctness"
-
-    @property
-    def requires_reference(self) -> bool:
-        return True
-
-    @property
-    def requires_input(self) -> bool:
-        return True
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: BaseLanguageModel,
-        prompt: Optional[PromptTemplate] = None,
-        **kwargs: Any,
-    ) -> QAEvalChain:
-        """Load QA Eval Chain from LLM.
-
-        Args:
-            llm (BaseLanguageModel): the base language model to use.
-
-            prompt (PromptTemplate): A prompt template containing the input_variables:
-            'input', 'answer' and 'result' that will be used as the prompt
-            for evaluation.
-            Defaults to PROMPT.
-
-            **kwargs: additional keyword arguments.
-
-        Returns:
-            QAEvalChain: the loaded QA eval chain.
-        """
-        prompt = prompt or PROMPT
-        expected_input_vars = {"query", "answer", "result"}
-        if expected_input_vars != set(prompt.input_variables):
-            msg = (
-                f"Input variables should be {expected_input_vars}, "
-                f"but got {prompt.input_variables}"
-            )
-            raise ValueError(msg)
-        return cls(llm=llm, prompt=prompt, **kwargs)
-
-    def evaluate(
-        self,
-        examples: Sequence[dict],
-        predictions: Sequence[dict],
-        question_key: str = "query",
-        answer_key: str = "answer",
-        prediction_key: str = "result",
-        *,
-        callbacks: Callbacks = None,
-    ) -> list[dict]:
-        """Evaluate question answering examples and predictions."""
-        inputs = [
-            {
-                "query": example[question_key],
-                "answer": example[answer_key],
-                "result": predictions[i][prediction_key],
-            }
-            for i, example in enumerate(examples)
-        ]
-
-        return self.apply(inputs, callbacks=callbacks)
-
-    def _prepare_output(self, result: dict) -> dict:
-        parsed_result = _parse_string_eval_output(result[self.output_key])
-        if RUN_KEY in result:
-            parsed_result[RUN_KEY] = result[RUN_KEY]
-        return parsed_result
-
-    @override
-    def _evaluate_strings(
-        self,
-        *,
-        prediction: str,
-        reference: Optional[str] = None,
-        input: Optional[str] = None,
-        callbacks: Callbacks = None,
-        include_run_info: bool = False,
-        **kwargs: Any,
-    ) -> dict:
-        """Evaluate Chain or LLM output, based on optional input and label.
-
-        Args:
-            prediction (str): the LLM or chain prediction to evaluate.
-            reference (Optional[str], optional): the reference label
-                to evaluate against.
-            input (Optional[str], optional): the input to consider during evaluation
-            callbacks (Callbacks, optional): the callbacks to use for tracing.
-            include_run_info (bool, optional): whether to include run info in the
-                returned results.
-            **kwargs: additional keyword arguments, including callbacks, tags, etc.
-        Returns:
-            dict: The evaluation results containing the score or value.
-        """
-        result = self(
-            {
-                "query": input,
-                "answer": reference,
-                "result": prediction,
-            },
-            callbacks=callbacks,
-            include_run_info=include_run_info,
-        )
-        return self._prepare_output(result)
-
-    @override
-    async def _aevaluate_strings(
-        self,
-        *,
-        prediction: str,
-        reference: Optional[str] = None,
-        input: Optional[str] = None,
-        callbacks: Callbacks = None,
-        include_run_info: bool = False,
-        **kwargs: Any,
-    ) -> dict:
-        result = await self.acall(
-            inputs={"query": input, "answer": reference, "result": prediction},
-            callbacks=callbacks,
-            include_run_info=include_run_info,
-        )
-        return self._prepare_output(result)
-
-
-class ContextQAEvalChain(LLMChain, StringEvaluator, LLMEvalChain):
-    """LLM Chain for evaluating QA w/o GT based on context"""
-
-    @classmethod
-    def is_lc_serializable(cls) -> bool:
-        return False
-
-    @property
-    def requires_reference(self) -> bool:
-        """Whether the chain requires a reference string."""
-        return True
-
-    @property
-    def requires_input(self) -> bool:
-        """Whether the chain requires an input string."""
-        return True
-
-    model_config = ConfigDict(
-        extra="ignore",
-    )
-
-    @classmethod
-    def _validate_input_vars(cls, prompt: PromptTemplate) -> None:
-        expected_input_vars = {"query", "context", "result"}
-        if expected_input_vars != set(prompt.input_variables):
-            msg = (
-                f"Input variables should be {expected_input_vars}, "
-                f"but got {prompt.input_variables}"
-            )
-            raise ValueError(msg)
-
-    @property
-    def evaluation_name(self) -> str:
-        return "Contextual Accuracy"
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: BaseLanguageModel,
-        prompt: Optional[PromptTemplate] = None,
-        **kwargs: Any,
-    ) -> ContextQAEvalChain:
-        """Load QA Eval Chain from LLM.
-
-        Args:
-            llm (BaseLanguageModel): the base language model to use.
-
-            prompt (PromptTemplate): A prompt template containing the input_variables:
-            'query', 'context' and 'result' that will be used as the prompt
-            for evaluation.
-            Defaults to PROMPT.
-
-            **kwargs: additional keyword arguments.
-
-        Returns:
-            ContextQAEvalChain: the loaded QA eval chain.
-        """
-        prompt = prompt or CONTEXT_PROMPT
-        cls._validate_input_vars(prompt)
-        return cls(llm=llm, prompt=prompt, **kwargs)
-
-    def evaluate(
-        self,
-        examples: list[dict],
-        predictions: list[dict],
-        question_key: str = "query",
-        context_key: str = "context",
-        prediction_key: str = "result",
-        *,
-        callbacks: Callbacks = None,
-    ) -> list[dict]:
-        """Evaluate question answering examples and predictions."""
-        inputs = [
-            {
-                "query": example[question_key],
-                "context": example[context_key],
-                "result": predictions[i][prediction_key],
-            }
-            for i, example in enumerate(examples)
-        ]
-
-        return self.apply(inputs, callbacks=callbacks)
-
-    def _prepare_output(self, result: dict) -> dict:
-        parsed_result = _parse_string_eval_output(result[self.output_key])
-        if RUN_KEY in result:
-            parsed_result[RUN_KEY] = result[RUN_KEY]
-        return parsed_result
-
-    @override
-    def _evaluate_strings(
-        self,
-        *,
-        prediction: str,
-        reference: Optional[str] = None,
-        input: Optional[str] = None,
-        callbacks: Callbacks = None,
-        include_run_info: bool = False,
-        **kwargs: Any,
-    ) -> dict:
-        result = self(
-            {
-                "query": input,
-                "context": reference,
-                "result": prediction,
-            },
-            callbacks=callbacks,
-            include_run_info=include_run_info,
-        )
-        return self._prepare_output(result)
-
-    @override
-    async def _aevaluate_strings(
-        self,
-        *,
-        prediction: str,
-        reference: Optional[str] = None,
-        input: Optional[str] = None,
-        callbacks: Callbacks = None,
-        include_run_info: bool = False,
-        **kwargs: Any,
-    ) -> dict:
-        result = await self.acall(
-            inputs={"query": input, "context": reference, "result": prediction},
-            callbacks=callbacks,
-            include_run_info=include_run_info,
-        )
-        return self._prepare_output(result)
-
-
-class CotQAEvalChain(ContextQAEvalChain):
-    """LLM Chain for evaluating QA using chain of thought reasoning."""
-
-    @classmethod
-    def is_lc_serializable(cls) -> bool:
-        return False
-
-    @property
-    def evaluation_name(self) -> str:
-        return "COT Contextual Accuracy"
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: BaseLanguageModel,
-        prompt: Optional[PromptTemplate] = None,
-        **kwargs: Any,
-    ) -> CotQAEvalChain:
-        """Load QA Eval Chain from LLM."""
-        prompt = prompt or COT_PROMPT
-        cls._validate_input_vars(prompt)
-        return cls(llm=llm, prompt=prompt, **kwargs)

langchain/evaluation/qa/eval_prompt.py

@@ -1,78 +0,0 @@
-from langchain_core.prompts import PromptTemplate
-
-template = """You are a teacher grading a quiz.
-You are given a question, the student's answer, and the true answer, and are asked to score the student answer as either CORRECT or INCORRECT.
-
-Example Format:
-QUESTION: question here
-STUDENT ANSWER: student's answer here
-TRUE ANSWER: true answer here
-GRADE: CORRECT or INCORRECT here
-
-Grade the student answers based ONLY on their factual accuracy. Ignore differences in punctuation and phrasing between the student answer and true answer. It is OK if the student answer contains more information than the true answer, as long as it does not contain any conflicting statements. Begin!
-
-QUESTION: {query}
-STUDENT ANSWER: {result}
-TRUE ANSWER: {answer}
-GRADE:"""  # noqa: E501
-PROMPT = PromptTemplate(
-    input_variables=["query", "result", "answer"], template=template
-)
-
-context_template = """You are a teacher grading a quiz.
-You are given a question, the context the question is about, and the student's answer. You are asked to score the student's answer as either CORRECT or INCORRECT, based on the context.
-
-Example Format:
-QUESTION: question here
-CONTEXT: context the question is about here
-STUDENT ANSWER: student's answer here
-GRADE: CORRECT or INCORRECT here
-
-Grade the student answers based ONLY on their factual accuracy. Ignore differences in punctuation and phrasing between the student answer and true answer. It is OK if the student answer contains more information than the true answer, as long as it does not contain any conflicting statements. Begin!
-
-QUESTION: {query}
-CONTEXT: {context}
-STUDENT ANSWER: {result}
-GRADE:"""  # noqa: E501
-CONTEXT_PROMPT = PromptTemplate(
-    input_variables=["query", "context", "result"], template=context_template
-)
-
-
-cot_template = """You are a teacher grading a quiz.
-You are given a question, the context the question is about, and the student's answer. You are asked to score the student's answer as either CORRECT or INCORRECT, based on the context.
-Write out in a step by step manner your reasoning to be sure that your conclusion is correct. Avoid simply stating the correct answer at the outset.
-
-Example Format:
-QUESTION: question here
-CONTEXT: context the question is about here
-STUDENT ANSWER: student's answer here
-EXPLANATION: step by step reasoning here
-GRADE: CORRECT or INCORRECT here
-
-Grade the student answers based ONLY on their factual accuracy. Ignore differences in punctuation and phrasing between the student answer and true answer. It is OK if the student answer contains more information than the true answer, as long as it does not contain any conflicting statements. Begin!
-
-QUESTION: {query}
-CONTEXT: {context}
-STUDENT ANSWER: {result}
-EXPLANATION:"""  # noqa: E501
-COT_PROMPT = PromptTemplate(
-    input_variables=["query", "context", "result"], template=cot_template
-)
-
-
-template = """You are comparing a submitted answer to an expert answer on a given SQL coding question. Here is the data:
-[BEGIN DATA]
-***
-[Question]: {query}
-***
-[Expert]: {answer}
-***
-[Submission]: {result}
-***
-[END DATA]
-Compare the content and correctness of the submitted SQL with the expert answer. Ignore any differences in whitespace, style, or output column names. The submitted answer may either be correct or incorrect. Determine which case applies. First, explain in detail the similarities or differences between the expert answer and the submission, ignoring superficial aspects such as whitespace, style or output column names. Do not state the final answer in your initial explanation. Then, respond with either "CORRECT" or "INCORRECT" (without quotes or punctuation) on its own line. This should correspond to whether the submitted SQL and the expert answer are semantically the same or different, respectively. Then, repeat your final answer on a new line."""  # noqa: E501
-
-SQL_PROMPT = PromptTemplate(
-    input_variables=["query", "answer", "result"], template=template
-)

langchain/evaluation/qa/generate_chain.py

@@ -1,34 +0,0 @@
-"""LLM Chain for generating examples for question answering."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers import BaseLLMOutputParser
-from pydantic import Field
-
-from langchain.chains.llm import LLMChain
-from langchain.evaluation.qa.generate_prompt import PROMPT
-from langchain.output_parsers.regex import RegexParser
-
-_QA_OUTPUT_PARSER = RegexParser(
-    regex=r"QUESTION: (.*?)\n+ANSWER: (.*)",
-    output_keys=["query", "answer"],
-)
-
-
-class QAGenerateChain(LLMChain):
-    """LLM Chain for generating examples for question answering."""
-
-    output_parser: BaseLLMOutputParser = Field(default=_QA_OUTPUT_PARSER)
-    output_key: str = "qa_pairs"
-
-    @classmethod
-    def is_lc_serializable(cls) -> bool:
-        return False
-
-    @classmethod
-    def from_llm(cls, llm: BaseLanguageModel, **kwargs: Any) -> QAGenerateChain:
-        """Load QA Generate Chain from LLM."""
-        return cls(llm=llm, prompt=PROMPT, **kwargs)

langchain/evaluation/qa/generate_prompt.py

@@ -1,21 +0,0 @@
-from langchain_core.prompts import PromptTemplate
-
-template = """You are a teacher coming up with questions to ask on a quiz.
-Given the following document, please generate a question and answer based on that document.
-
-Example Format:
-<Begin Document>
-...
-<End Document>
-QUESTION: question here
-ANSWER: answer here
-
-These questions should be detailed and be based explicitly on information in the document. Begin!
-
-<Begin Document>
-{doc}
-<End Document>"""  # noqa: E501
-PROMPT = PromptTemplate(
-    input_variables=["doc"],
-    template=template,
-)

langchain/evaluation/regex_match/base.py

@@ -1,86 +0,0 @@
-import re
-from typing import Any
-
-from langchain.evaluation.schema import StringEvaluator
-
-
-class RegexMatchStringEvaluator(StringEvaluator):
-    """Compute a regex match between the prediction and the reference.
-
-    Examples
-    ----------
-    >>> evaluator = RegexMatchStringEvaluator(flags=re.IGNORECASE)
-    >>> evaluator.evaluate_strings(
-            prediction="Mindy is the CTO",
-            reference="^mindy.*cto$",
-        )  # This will return {'score': 1.0} due to the IGNORECASE flag
-
-    >>> evaluator = RegexMatchStringEvaluator()
-    >>> evaluator.evaluate_strings(
-            prediction="Mindy is the CTO",
-            reference="^Mike.*CEO$",
-        )  # This will return {'score': 0.0}
-
-    >>> evaluator.evaluate_strings(
-            prediction="Mindy is the CTO",
-            reference="^Mike.*CEO$|^Mindy.*CTO$",
-        )  # This will return {'score': 1.0} as the prediction matches the second pattern in the union
-    """  # noqa: E501
-
-    def __init__(self, *, flags: int = 0, **kwargs: Any):  # Default is no flags
-        super().__init__()
-        self.flags = flags
-
-    @property
-    def requires_input(self) -> bool:
-        """
-        This evaluator does not require input.
-        """
-        return False
-
-    @property
-    def requires_reference(self) -> bool:
-        """
-        This evaluator requires a reference.
-        """
-        return True
-
-    @property
-    def input_keys(self) -> list[str]:
-        """
-        Get the input keys.
-
-        Returns:
-            List[str]: The input keys.
-        """
-        return ["reference", "prediction"]
-
-    @property
-    def evaluation_name(self) -> str:
-        """
-        Get the evaluation name.
-
-        Returns:
-            str: The evaluation name.
-        """
-        return "regex_match"
-
-    def _evaluate_strings(  # type: ignore[override]
-        self,
-        *,
-        prediction: str,
-        reference: str,
-        **kwargs: Any,
-    ) -> dict:
-        """
-        Evaluate the regex match between the prediction and the reference.
-
-        Args:
-            prediction (str): The prediction string.
-            reference (Optional[str], optional): The reference regex pattern.
-
-        Returns:
-            dict: The evaluation results containing the score.
-        """
-        match = re.match(reference, prediction, flags=self.flags)
-        return {"score": int(bool(match))}