如何创建一个自定义的输出解析器

在某些情况下，您可能希望实现一个自定义的解析器，以将模型输出结构化为自定义格式。

有两种方法可以实现自定义解析器：

在LCEL中使用RunnableLambda或RunnableGenerator——我们强烈推荐在大多数用例中使用这种方法
通过继承其中一个用于解析的基类——这是实现功能的复杂方式

这两种方法之间的差异大多是表面的，主要在于触发的回调函数不同（例如，on_chain_start 与 on_parser_start），以及在像LangSmith这样的追踪平台中，可运行的lambda与解析器的可视化方式可能有所不同。

可运行的 Lambdas 和生成器

推荐的解析方式是使用可运行的lambda表达式和可运行的生成器！

在这里，我们将创建一个简单的解析器，用于反转模型输出的字母大小写。

例如，如果模型输出："Meow"，解析器将生成"mEOW"。

from typing import Iterable

from langchain_anthropic.chat_models import ChatAnthropic
from langchain_core.messages import AIMessage, AIMessageChunk

model = ChatAnthropic(model_name="claude-2.1")


def parse(ai_message: AIMessage) -> str:
    """Parse the AI message."""
    return ai_message.content.swapcase()


chain = model | parse
chain.invoke("hello")

API Reference:ChatAnthropic | AIMessage | AIMessageChunk

'hELLO!'

tip

LCEL 在使用 | 语法组合时，自动将函数 parse 升级为 RunnableLambda(parse)。

如果你不喜欢那样，你可以手动导入 RunnableLambda 然后运行 parse = RunnableLambda(parse)。

流式传输有效吗？

for chunk in chain.stream("tell me about yourself in one sentence"):
    print(chunk, end="|", flush=True)

i'M cLAUDE, AN ai ASSISTANT CREATED BY aNTHROPIC TO BE HELPFUL, HARMLESS, AND HONEST.|

不，它不会，因为解析器在解析输出之前会聚合输入。

如果我们想要实现一个流式解析器，我们可以让解析器接受一个可迭代的输入，并在结果可用时生成它们。

from langchain_core.runnables import RunnableGenerator

def streaming_parse(chunks: Iterable[AIMessageChunk]) -> Iterable[str]:
    for chunk in chunks:
        yield chunk.content.swapcase()

streaming_parse = RunnableGenerator(streaming_parse)

API Reference:RunnableGenerator

important

请将流式解析器包装在RunnableGenerator中，因为我们可能会停止使用|语法自动升级它。

chain = model | streaming_parse
chain.invoke("hello")

'hELLO!'

让我们确认流式传输是否有效！

for chunk in chain.stream("tell me about yourself in one sentence"):
    print(chunk, end="|", flush=True)

i|'M| cLAUDE|,| AN| ai| ASSISTANT| CREATED| BY| aN|THROP|IC| TO| BE| HELPFUL|,| HARMLESS|,| AND| HONEST|.|

从解析基类继承

实现解析器的另一种方法是通过继承BaseOutputParser、BaseGenerationOutputParser或其他基础解析器之一，具体取决于你需要做什么。

一般来说，我们不推荐大多数使用场景采用这种方法，因为它会导致编写更多的代码而没有显著的好处。

最简单的输出解析器扩展了BaseOutputParser类，并且必须实现以下方法：

parse: 获取模型的字符串输出并解析它
(可选) _type: 标识解析器的名称。

当聊天模型或LLM的输出格式不正确时，可以抛出OutputParserException来指示由于输入错误导致解析失败。使用此异常允许使用解析器的代码以一致的方式处理异常。

Parsers are Runnables! 🏃

因为 BaseOutputParser 实现了 Runnable 接口，任何你以这种方式创建的自定义解析器都将成为有效的 LangChain Runnables，并受益于自动异步支持、批处理接口、日志支持等。

简单解析器

这是一个简单的解析器，可以解析字符串表示的布尔值（例如，YES 或 NO）并将其转换为相应的boolean类型。

from langchain_core.exceptions import OutputParserException
from langchain_core.output_parsers import BaseOutputParser


# The [bool] desribes a parameterization of a generic.
# It's basically indicating what the return type of parse is
# in this case the return type is either True or False
class BooleanOutputParser(BaseOutputParser[bool]):
    """Custom boolean parser."""

    true_val: str = "YES"
    false_val: str = "NO"

    def parse(self, text: str) -> bool:
        cleaned_text = text.strip().upper()
        if cleaned_text not in (self.true_val.upper(), self.false_val.upper()):
            raise OutputParserException(
                f"BooleanOutputParser expected output value to either be "
                f"{self.true_val} or {self.false_val} (case-insensitive). "
                f"Received {cleaned_text}."
            )
        return cleaned_text == self.true_val.upper()

    @property
    def _type(self) -> str:
        return "boolean_output_parser"

API Reference:OutputParserException | BaseOutputParser

parser = BooleanOutputParser()
parser.invoke("YES")

True

try:
    parser.invoke("MEOW")
except Exception as e:
    print(f"Triggered an exception of type: {type(e)}")

Triggered an exception of type: <class 'langchain_core.exceptions.OutputParserException'>

让我们测试更改参数化

parser = BooleanOutputParser(true_val="OKAY")
parser.invoke("OKAY")

True

让我们确认其他LCEL方法是否存在

parser.batch(["OKAY", "NO"])

[True, False]

await parser.abatch(["OKAY", "NO"])

[True, False]

from langchain_anthropic.chat_models import ChatAnthropic

anthropic = ChatAnthropic(model_name="claude-2.1")
anthropic.invoke("say OKAY or NO")

API Reference:ChatAnthropic

AIMessage(content='OKAY')

让我们测试一下我们的解析器是否工作！

chain = anthropic | parser
chain.invoke("say OKAY or NO")

True

note

解析器将适用于LLM的输出（一个字符串）或聊天模型的输出（一个AIMessage）！

解析原始模型输出

有时，除了原始文本之外，模型输出上还有其他重要的元数据。其中一个例子是工具调用，其中传递给被调用函数的参数会在一个单独的属性中返回。如果您需要这种更细粒度的控制，您可以改为子类化BaseGenerationOutputParser类。

这个类需要一个单一的方法 parse_result。这个方法接收原始模型输出（例如，Generation 或 ChatGeneration 的列表）并返回解析后的输出。

支持Generation和ChatGeneration使得解析器能够与常规的LLMs以及聊天模型一起工作。

from typing import List

from langchain_core.exceptions import OutputParserException
from langchain_core.messages import AIMessage
from langchain_core.output_parsers import BaseGenerationOutputParser
from langchain_core.outputs import ChatGeneration, Generation


class StrInvertCase(BaseGenerationOutputParser[str]):
    """An example parser that inverts the case of the characters in the message.

    This is an example parse shown just for demonstration purposes and to keep
    the example as simple as possible.
    """

    def parse_result(self, result: List[Generation], *, partial: bool = False) -> str:
        """Parse a list of model Generations into a specific format.

        Args:
            result: A list of Generations to be parsed. The Generations are assumed
                to be different candidate outputs for a single model input.
                Many parsers assume that only a single generation is passed it in.
                We will assert for that
            partial: Whether to allow partial results. This is used for parsers
                     that support streaming
        """
        if len(result) != 1:
            raise NotImplementedError(
                "This output parser can only be used with a single generation."
            )
        generation = result[0]
        if not isinstance(generation, ChatGeneration):
            # Say that this one only works with chat generations
            raise OutputParserException(
                "This output parser can only be used with a chat generation."
            )
        return generation.message.content.swapcase()


chain = anthropic | StrInvertCase()

API Reference:OutputParserException | AIMessage | BaseGenerationOutputParser | ChatGeneration | Generation

让我们使用新的解析器！它应该反转模型的输出。

chain.invoke("Tell me a short sentence about yourself")

'hELLO! mY NAME IS cLAUDE.'

可运行的 Lambdas 和生成器​

从解析基类继承​

简单解析器​

解析原始模型输出​

这个页面有帮助吗？

可运行的 Lambdas 和生成器

从解析基类继承

简单解析器

解析原始模型输出