如何创建自定义输出解析器
在某些情况下,您可能希望实现一个自定义的解析器,以便将模型输出结构化为自定义格式。
有两种方法可以实现自定义解析器
- 在 LCEL 中使用
RunnableLambda
或RunnableGenerator
—— 我们强烈推荐这种方法适用于大多数用例 - 通过继承其中一个用于输出解析的基类 —— 这种方法比较复杂
这两种方法之间的差异大多是表面上的,主要在于触发哪些回调(例如,on_chain_start
vs. on_parser_start
),以及可运行 lambda 与解析器在 LangSmith 等追踪平台中如何可视化。
可运行 Lambda 和生成器
推荐的解析方式是使用**可运行 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")
'hELLO!'
当使用 `|` 语法组合时,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.|
不,它不行,因为解析器在解析输出之前会聚合输入。
如果我们想实现一个流式解析器,我们可以让解析器接受输入的迭代器,并根据结果的可用性进行生成(yield)。
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)
请将流式解析器包装在 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
来指示解析失败是由于输入不良造成的。使用此异常可以使利用该解析器的代码以一致的方式处理异常。
因为 BaseOutputParser
实现了 Runnable
接口,所以您以这种方式创建的任何自定义解析器都将成为有效的 LangChain 可运行对象,并受益于自动异步支持、批处理接口、日志记录支持等功能。
简单解析器
这是一个简单的解析器,它可以解析布尔值的**字符串**表示(例如,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"
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")
AIMessage(content='OKAY')
让我们测试我们的解析器是否有效!
chain = anthropic | parser
chain.invoke("say OKAY or NO")
True
该解析器既可以处理 LLM 的输出(字符串),也可以处理聊天模型的输出(AIMessage
)!
解析原始模型输出
有时,模型输出中除了原始文本之外,还有一些重要的额外元数据。一个例子是工具调用,其中旨在传递给被调用函数的参数会在单独的属性中返回。如果您需要这种更细粒度的控制,可以转而继承 BaseGenerationOutputParser
类。
这个类需要一个方法 parse_result
。这个方法接受原始模型输出(例如,Generation
或 ChatGeneration
列表),并返回解析后的输出。
支持 Generation
和 ChatGeneration
允许解析器同时与普通 LLM 和聊天模型配合使用。
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()
让我们尝试新的解析器!它应该会反转模型的输出。
chain.invoke("Tell me a short sentence about yourself")
'hELLO! mY NAME IS cLAUDE.'