【LangChain】langchain_core.language_models.llms.BaseLLM 类中的常用方法和属性

于 2025-05-08 00:03:21 发布
阅读量575 收藏 15
点赞数 7
分类专栏： LangChain 文章标签： langchain langchain_core language_models BaseLLM invoke generate stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013172930/article/details/147776786
版权

langchain_core.language_models.llms.BaseLLM 类中的常用方法和属性，这是 LangChain 中所有语言模型的基类，用于定义 LLM（如 OllamaLLM、OpenAI 等）的核心接口。

本文基于 LangChain 0.3.x，详细介绍 BaseLLM 的常用方法和属性，包括定义、参数、返回值和典型场景，并提供一个独立示例，展示如何使用 langchain_ollama.OllamaLLM（继承 BaseLLM）的常用方法（invoke、generate、stream）处理人工智能主题的问答，示例使用 llama3 模型，突出方法的使用方式。

BaseLLM 简介

langchain_core.language_models.llms.BaseLLM 是 LangChain 中语言模型的抽象基类，定义了所有 LLM 的标准接口。它不直接实现生成逻辑，而是由子类（如 OllamaLLM、OpenAI）提供具体实现。BaseLLM 提供了一致的 API，方便在不同模型间切换，同时支持同步、异步和流式调用。

核心功能：

  • 定义 LLM 的生成接口（如 invoke、generate、stream）。
  • 支持批量处理、回调和元数据管理。
  • 提供属性配置模型行为（如 temperature、max_tokens）。

适用场景：

  • 构建对话系统、问答系统或 RAG 应用。
  • 批量处理文本生成任务。
  • 集成到 LCEL（LangChain Expression Language）链。
  • 跨模型统一调用（如从本地 Ollama 切换到云端 OpenAI）。

常用方法

以下是 BaseLLM 的常用方法，基于 LangChain 源码（langchain_core/language_models/llms.py）和官方文档（BaseLLM)。方法按使用频率排序。

1. invoke
def invoke(
    self,
    input: str,
    config: Optional[RunnableConfig] = None,
    *,
    stop: Optional[List[str]] = None,
    **kwargs: Any
) -> str
  • 功能：同步调用模型，处理单个输入，返回生成文本。
  • 参数：
    • input：输入提示字符串。
    • config：运行时配置（如 max_tokens、callbacks）。
    • stop：停止词列表。
    • **kwargs：模型特定参数（如 temperature）。
  • 返回值：str，生成的文本。
  • 使用场景：
    • 简单问答或单次生成。
    • LCEL 链中的标准调用。
  • 示例：
    response = llm.invoke("什么是人工智能？")
print(response)  # 人工智能是...
2. generate
def generate(
    self,
    prompts: List[str],
    stop: Optional[List[str]] = None,
    callbacks: Optional[Callbacks] = None,
    tags: Optional[List[str]] = None,
    metadata: Optional[Dict[str, Any]] = None,
    run_name: Optional[str] = None,
    run_id: Optional[uuid.UUID] = None,
    **kwargs: Any
) -> LLMResult
  • 功能：批量处理多个提示，返回结构化的生成结果。
  • 参数：
    • prompts：提示列表。
    • stop：停止词列表。
    • callbacks：回调函数。
    • tags/metadata：跟踪标签和元数据。
    • run_name/run_id：运行名称和 ID。
    • **kwargs：模型参数。
  • 返回值：LLMResult，包含：
    • generations：List[List[Generation]]，每个提示的生成结果。
    • llm_output：模型元数据（如 token 计数）。
    • run：运行信息。
  • 使用场景：
    • 批量问答或多任务生成。
    • 需要结构化输出（如 token 使用量）。
  • 示例：
    result = llm.generate(["什么是人工智能？", "AI 有哪些应用？"])
for generations in result.generations:
    print(generations[0].text)
3. stream
def stream(
    self,
    input: str,
    config: Optional[RunnableConfig] = None,
    *,
    stop: Optional[List[str]] = None,
    **kwargs: Any
) -> Iterator[str]
  • 功能：流式生成文本，逐块返回结果。
  • 参数：同 invoke。
  • 返回值：Iterator[str]，生成文本的迭代器。
  • 使用场景：
    • 实时显示生成结果（如聊天界面）。
    • 处理长输出。
  • 示例：
    for chunk in llm.stream("人工智能有哪些应用？"):
    print(chunk, end="", flush=True)
4. ainvoke
async def ainvoke(
    self,
    input: str,
    config: Optional[RunnableConfig] = None,
    *,
    stop: Optional[List[str]] = None,
    **kwargs: Any
) -> str
  • 功能：异步调用模型，处理单个输入。
  • 参数：同 invoke。
  • 返回值：Awaitable[str]，异步返回生成文本。
  • 使用场景：
    • 高并发 Web 服务。
    • 异步工作流。
  • 示例：
    import asyncio
async def run():
    response = await llm.ainvoke("什么是人工智能？")
    print(response)
asyncio.run(run())
5. agenerate
async def agenerate(
    self,
    prompts: List[str],
    stop: Optional[List[str]] = None,
    callbacks: Optional[Callbacks] = None,
    tags: Optional[List[str]] = None,
    metadata: Optional[Dict[str, Any]] = None,
    run_name: Optional[str] = None,
    run_id: Optional[uuid.UUID] = None,
    **kwargs: Any
) -> LLMResult
  • 功能：异步批量生成。
  • 参数：同 generate。
  • 返回值：Awaitable[LLMResult]。
  • 使用场景：
    • 异步批量处理。
    • 高吞吐量场景。
  • 示例：
    async def run():
    result = await llm.agenerate(["问题1", "问题2"])
    for generations in result.generations:
        print(generations[0].text)
asyncio.run(run())
6. astream
async def astream(
    self,
    input: str,
    config: Optional[RunnableConfig] = None,
    *,
    stop: Optional[List[str]] = None,
    **kwargs: Any
) -> AsyncIterator[str]
  • 功能：异步流式生成。
  • 参数：同 stream。
  • 返回值：AsyncIterator[str]，异步生成文本的迭代器。
  • 使用场景：
    • 实时 WebSocket 聊天。
    • 异步流式输出。
  • 示例：
    async def run():
    async for chunk in llm.astream("人工智能有哪些应用？"):
        print(chunk, end="", flush=True)
asyncio.run(run())
方法总结
方法功能返回值典型场景
invoke同步单次生成str简单问答
generate同步批量生成LLMResult批量处理
stream同步流式生成Iterator[str]实时输出
ainvoke异步单次生成Awaitable[str]异步服务
agenerate异步批量生成Awaitable[LLMResult]高并发批量
astream异步流式生成AsyncIterator[str]Web 服务

推荐方法：

  • invoke：单次生成，LCEL 链标准调用。
  • generate：批量处理，需结构化输出。
  • stream：实时交互。

常用属性

以下是 BaseLLM 的常用属性，基于源码和文档。

1. cache
  • 类型：Optional[BaseCache]
  • 功能：控制生成结果的缓存，默认 None（不缓存）。
  • 使用场景：缓存重复查询结果，优化性能。
  • 示例：
    from langchain_core.caches import InMemoryCache
llm.cache = InMemoryCache()
response = llm.invoke("相同问题")  # 第二次调用从缓存读取
2. metadata
  • 类型：Dict[str, Any]
  • 功能：存储模型的元数据（如模型名称、版本）。
  • 使用场景：记录模型信息，供调试或日志。
  • 示例：
    print(llm.metadata)  # {'model': 'llama3', ...}
3. callbacks
  • 类型：Optional[Callbacks]
  • 功能：默认回调函数，应用于所有调用。
  • 使用场景：记录生成过程或集成追踪工具（如 LangSmith）。
  • 示例：
    from langchain_core.callbacks import StdOutCallbackHandler
llm.callbacks = [StdOutCallbackHandler()]
response = llm.invoke("测试")
4. Configurable Fields（通过 ConfigurableField）
  • 功能：动态配置模型参数（如 temperature、max_tokens）。
  • 常见字段（子类实现）：
    • model：模型名称（如 llama3）。
    • temperature：生成随机性（0~1）。
    • max_tokens：最大输出 token 数。
  • 使用场景：运行时调整模型行为。
  • 示例：
    llm = OllamaLLM(model="llama3", temperature=0.7)
print(llm.temperature)  # 0.7
属性总结
属性类型功能典型场景
cacheOptional[BaseCache]缓存生成结果优化性能
metadataDict[str, Any]模型元数据调试/日志
callbacksOptional[Callbacks]默认回调追踪/监控
temperaturefloat生成随机性控制输出
max_tokensint最大 token限制长度

推荐属性：

  • cache：提升重复查询效率。
  • temperature：调整生成风格。

使用 BaseLLM 常用方法的问答示例

以下是一个独立示例，展示如何使用 langchain_ollama.OllamaLLM（继承 BaseLLM）的常用方法（invoke、generate、stream）处理人工智能主题的问答，结合 PromptTemplate 格式化输入。

准备 Ollama：

  • 启动 Ollama 服务：
    ollama serve
  • 拉取模型：
    ollama pull llama3

代码：

from langchain_ollama import OllamaLLM
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_core.caches import InMemoryCache

# 初始化 LLM
llm = OllamaLLM(
    model="llama3",
    base_url="http://localhost:11434",
    temperature=0.7,
    max_tokens=512,
    cache=InMemoryCache()  # 启用缓存
)

# 定义 PromptTemplate
prompt = PromptTemplate(
    template="""你是一个人工智能专家，回答以下问题：
问题：{question}
回答：""",
    input_variables=["question"]
)

# 创建问答链
qa_chain = (
    {"question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# 1. 使用 invoke 方法（单次生成）
print("1. invoke 方法：")
response = llm.invoke(
    prompt.format(question="什么是人工智能？"),
    stop=["\n"]
)
print(response)

# 2. 使用 generate 方法（批量生成）
print("\n2. generate 方法：")
questions = [
    "什么是人工智能？",
    "人工智能有哪些应用？"
]
result = llm.generate(
    prompts=[prompt.format(question=q) for q in questions],
    stop=["\n"],
    temperature=0.7
)
for i, generations in enumerate(result.generations):
    print(f"问题 {i+1}: {questions[i]}")
    print(f"回答: {generations[0].text}")

# 3. 使用 stream 方法（流式生成）
print("\n3. stream 方法：")
for chunk in llm.stream(
    prompt.format(question="机器学习和人工智能的区别是什么？"),
    stop=["\n"]
):
    print(chunk, end="", flush=True)
print()

# 查看属性
print("\n4. 常用属性：")
print(f"模型元数据: {llm.metadata}")
print(f"缓存状态: {llm.cache is not None}")
print(f"温度: {llm.temperature}")

输出示例（取决于模型和硬件，实际输出可能略有不同）：

1. invoke 方法：
人工智能是计算机科学的一个分支，涉及开发智能机器。

2. generate 方法：
问题 1: 什么是人工智能？
回答: 人工智能是计算机科学的一个分支，涉及开发智能机器。
问题 2: 人工智能有哪些应用？
回答: 人工智能的应用包括自动驾驶、语音识别和医疗诊断。

3. stream 方法：
机器学习是人工智能的子集，专注于从数据中学习模型。

4. 常用属性：
模型元数据: {'model': 'llama3'}
缓存状态: True
温度: 0.7
代码说明
  1. LLM 初始化：
    • 使用 OllamaLLM 调用 llama3，配置 temperature=0.7、max_tokens=512。
    • 启用 InMemoryCache 缓存。
  2. 提示模板：
    • PromptTemplate 格式化人工智能问题。
  3. 方法使用：
    • invoke：单次生成“什么是人工智能？”。
    • generate：批量生成两个问题。
    • stream：流式生成第三个问题。
  4. 属性展示：
    • 打印 metadata、cache 状态和 temperature。
  5. 主题：
    • 示例聚焦人工智能问答，突出 BaseLLM 方法和属性。
  6. 独立性：
    • 不涉及嵌入、匿名化或之前的上下文。

运行要求：

  • Ollama 服务运行且 llama3 模型已拉取：
    ollama serve
ollama pull llama3
  • 安装依赖：
    pip install --upgrade langchain langchain-ollama
  • 硬件支持：llama3:8b 需 8GB+ RAM，GPU 可加速。

注意事项

  1. Ollama 服务：
    • 验证服务：
      curl http://localhost:11434
    • 确保模型已拉取：
      ollama list
    • 远程服务：
      llm = OllamaLLM(base_url="http://your-ollama-server:11434")
  2. 方法选择：
    • invoke：适合单次调用，简单直接。
    • generate：适合批量处理，需解析 LLMResult。
    • stream：适合实时交互，需逐块处理。
  3. 属性配置：
    • 缓存：启用 InMemoryCache 优化重复查询：
      llm.cache = InMemoryCache()
    • 回调：添加 StdOutCallbackHandler 记录过程：
      llm.callbacks = [StdOutCallbackHandler()]
    • 温度：调整 temperature 控制随机性：
      llm = OllamaLLM(temperature=0.5)
  4. 性能优化：
    • 批量处理：generate 适合多提示，分块处理大批量：
      prompts = prompts[:100]
result = llm.generate(prompts)
    • 异步调用：使用 ainvoke 或 agenerate：
      result = asyncio.run(llm.agenerate(prompts))
    • GPU 加速：Ollama 支持 NVIDIA GPU：
      nvidia-smi
  5. 错误调试：
    • 服务不可用：
      • 检查 Ollama 服务：
        ollama serve
      • 验证 base_url：
        import requests
requests.get("http://localhost:11434")
    • 生成为空：
      • 检查提示：
        print(prompt.format(question="测试"))
      • 增加 max_tokens：
        llm = OllamaLLM(max_tokens=1024)
    • 属性不可用：
      • 确认子类支持：
        print(hasattr(llm, "temperature"))  # True

常见问题

Q1：如何选择 invoke 和 generate？
A：

  • invoke：单次调用，简单场景。
  • generate：批量调用，需结构化输出（如 LLMResult）。
response = llm.invoke("问题")  # 单次
result = llm.generate(["问题1", "问题2"])  # 批量

Q2：如何启用缓存？
A：设置 cache 属性：

from langchain_core.caches import InMemoryCache
llm.cache = InMemoryCache()
response = llm.invoke("相同问题")  # 缓存命中

Q3：如何与 LCEL 链集成？
A：将 LLM 嵌入链：

chain = prompt | llm | StrOutputParser()
response = chain.invoke("问题")
# 批量
results = chain.batch(["问题1", "问题2"])

Q4：如何记录生成过程？
A：使用回调：

from langchain_core.callbacks import StdOutCallbackHandler
result = llm.generate(["问题"], callbacks=[StdOutCallbackHandler()])

总结

langchain_core.language_models.llms.BaseLLM 提供了一致的 LLM 接口，常用方法和属性包括：

  • 方法：
    • invoke：单次同步生成。
    • generate：批量同步生成。
    • stream：流式生成。
    • ainvoke/agenerate/astream：异步版本。
  • 属性：
    • cache：缓存结果。
    • metadata：模型信息。
    • callbacks：默认回调。
    • temperature/max_tokens：生成参数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

彬彬侠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值