LangChain之模型调用_langchain调用模型

Model I/O

概述

LangChain的模型是框架中的核心，基于语言模型构建，用于开发LangChain应用。通过API调用大模型来解决问题是LangChain应用开发的关键过程。

可以把对模型的使用过程拆解成三块: 输入提示(Format)、调用模型(Predict)、输出解析(Parse)

1.提示模板: LangChain的模板允许动态选择输入，根据实际需求调整输入内容，适用于各种特定任务和应用。

2.语言模型: LangChain 提供通用接口调用不同类型的语言模型，提升了灵活性和使用便利性。

3.输出解析: 利用 LangChain 的输出解析功能，精准提取模型输出中所需信息，避免处理冗余数据，同时将非结构化文本转换为可处理的结构化数据，提高信息处理效率。
1
2
3
4
5

这三块形成了一个整体，在LangChain中这个过程被统称为Model I/O。针对每块环节，LangChain都提供了模板和工具，可以帮助快捷的调用各种语言模型的接口。

Model 模型

LangChain支持的模型有三大类

1.大语言模型（LLM） ，也叫Text Model，这些模型将文本字符串作为输入，并返回文本字符串作为输出。

2.聊天模型（Chat Model），主要代表Open AI的ChatGPT系列模型。这些模型通常由语言模型支持，但它们的API更加结构化。具体来说，这些模型将聊天消息列表作为输入，并返回聊天消息。

3.文本嵌入模型（Embedding Model），这些模型将文本作为输入并返回浮点数列表，也就是Embedding。
1
2
3
4
5

大语言模型与聊天模型区别：

聊天模型通常由大语言模型支持，但专门调整为对话场景。重要的是，它们的提供商API使用不同于纯文本模型的接口。输入被处理为聊天消息列表，输出为AI生成的消息。

LangChain中的LLM指的是纯文本补全模型。它们包装的 API 将字符串提示作为输入并输出字符串完成。

调用OpenAI模型

设置环境变量

import os
os.environ["OPENAI_BASE_URL"] = "https://xxx.com/v1"
os.environ["OPENAI_API_KEY"] = "sk-fDqouTlU62yjkBhF46284543Dc8f42438a9529Df74B4Ce65"
1
2
3

大语言模型LLM

LangChain的核心组件是大型语言模型（LLM），它提供一个标准接口以字符串作为输入并返回字符串的形式与多个不同的LLM进行交互。这一接口旨在为诸如OpenAI、Cohere、Hugging Face等多家LLM供应商提供标准化的对接方法。

from langchain_openai import OpenAI

text = "你好"
# LLM纯文本补全模型
llm = OpenAI()
res = llm.invoke(text)
print(text + res)
1
2
3
4
5
6
7

你好，世界！
1

异步支持对于同时调用多个LLM特别有用，因为这些调用是网络限制的。

可以使用agenerate方法异步调用LLM

import time
import asyncio
from langchain_openai import OpenAI


# 定义一个函数，使用OpenAI的API生成文本并依次打印结果
def generate_serially():
    llm = OpenAI(temperature=0.9)  # 初始化 OpenAI 实例
    for _ in range(5):
        resp = llm.generate(["你好啊?"])  # 调用生成方法，传入文本请求
        print(resp.generations[0][0].text)  # 打印生成的文本结果


# 定义一个异步函数，使用OpenAI的API异步生成文本并打印结果
async def async_generate(llm):
    resp = await llm.agenerate(["你是谁?"])  # 异步调用生成方法，传入文本请求
    print(resp.generations[0][0].text)  # 打印异步生成的文本结果


# 定义一个异步函数，用于并发执行多个 async_generate 函数
async def generate_concurrently():
    llm = OpenAI(temperature=0.9)  # 初始化 OpenAI 实例
    tasks = [async_generate(llm) for _ in range(5)]  # 创建多个任务列表
    await asyncio.gather(*tasks)  # 并发等待所有任务完成


# 计算并发执行时间
s = time.perf_counter()  # 记录开始时间
asyncio.run(generate_concurrently())  # 运行异步函数
elapsed = time.perf_counter() - s  # 计算执行时间
print(f"异步执行 {elapsed:0.2f} 秒.")  # 打印并发执行时间

# 计算串行执行时间
s = time.perf_counter()  # 记录开始时间
generate_serially()  # 串行执行函数
elapsed = time.perf_counter() - s  # 计算执行时间
print(f"同步执行 {elapsed:0.2f} 秒.")  # 打印串行执行时间
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

我是一个人工智能程序，没有真正的身份。我被设计来回答问题和提供帮助。


我是一个人工智能助手，可以回答你关于技术或知识的问题。


我是一个程序，没有具体的身份。我是由人类编写的，用来帮助回答问题和执行任务的。

我是一台人工智能程序，无法具有实际的身份。我是由程序员编写和训练的，旨在通过语言交互来提供帮助和娱乐。

我是一个人工智能程序，被设计和程序员们一起工作，以帮助解决各种问题。我可以回答你的问题，提供帮助和建议。 
异步执行 6.20 秒.

你好，我是一个人工智能助手。有什么可以帮到您的吗？


我是一个程序，无法感受情绪，但是很高兴能和你交流。你好吗？


你好！我是一个人工智能助手，很高兴认识你。有什么可以帮助你的吗？


你好，我是一个智能助手，很高兴认识你。有什么可以帮助你的吗？


Hello! How are you? 
同步执行 10.29 秒.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

聊天模型

聊天模型是LangChain的核心组件，使用聊天消息作为输入并返回聊天消息作为输出。

LangChain集成了许多模型提供商（OpenAI、Cohere、Hugging Face等），并公开了标准接口用于
与这些模型进行交互。

LangChain允许在同步、异步、批处理和流模式下使用模型，并提供其他功能，如缓存。
1
2
3
4
5
6

LangChain有一些内置的消息类型：

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

text = "你好"
# 聊天模型
chat_model = ChatOpenAI(model="gpt-3.5-turbo")
messages = [HumanMessage(content=text)]

res = chat_model.invoke(messages)
print(res)
1
2
3
4
5
6
7
8
9
10

content='你好！有什么可以帮助你的吗？' response_metadata={'token_usage': {'completion_tokens': 17, 'prompt_tokens': 9, 'total_tokens': 26}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None} id='run-c1641695-dab6-44f3-9037-44904cc166e9-0'
1

聊天模型支持多个消息作为输入

messages = [
    SystemMessage(content="你是一位乐于助人的助手。"),
    HumanMessage(content="你好")
]
chat.invoke(messages)
1
2
3
4
5

文本嵌入模型

Embedding类是一个用于与嵌入进行交互的类。有许多嵌入提供商（OpenAI、Cohere、Hugging Face等)- 这个类旨在为所有这些提供商提供一个标准接口。

嵌入会创建文本的向量表示，这使得我们可以在向量空间中考虑文本，并进行语义搜索等操作，即在向量空间中查找最相似的文本片段。

from langchain_openai import OpenAIEmbeddings

# 初始化 OpenAIEmbeddings 实例
embeddings = OpenAIEmbeddings()
# embeddings = OpenAIEmbeddings(model="text-embedding-3-large")

# 定义一个文本字符串
text = "这是一份测试文档."

# 嵌入文档
doc_result = embeddings.embed_documents([text])
print(doc_result[0][:5])

# 嵌入查询
query_result = embeddings.embed_query(text)
print(query_result[:5])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

[-0.006240383366130216, -0.003690876131687136, 0.0035220345636857247, -0.006399094239817186, -0.013473554751640016]

[-0.006240383366130216, -0.003690876131687136, 0.0035220345636857247, -0.006399094239817186, -0.013473554751640016]
1
2
3

调用谷歌模型

通过langchain-google-genai集成包中的类ChatGoogleGenerativeAI，访问 Google AIgemini和gemini-vision模型，以及其他生成模型 。

环境准备

安装langchain-google-genai包

pip install langchain-google-genai
1

访问Google AI Studio，创建API密钥

import os

# 设置API_Key
os.environ["GOOGLE_API_KEY"] = ''
1
2
3
4

聊天模型

from langchain_google_genai import ChatGoogleGenerativeAI

llm = ChatGoogleGenerativeAI(model="gemini-pro")
res = llm.invoke("你好，你是谁？")
print(res)
1
2
3
4
5

SystemMessageGemini目前不支持，但可以设置convert_system_message_to_human=True来支持

from langchain_google_genai import ChatGoogleGenerativeAI

llm = ChatGoogleGenerativeAI(model="gemini-pro-vision")
from langchain_core.messages import HumanMessage, SystemMessage

model = ChatGoogleGenerativeAI(model="gemini-pro", Convert_system_message_to_human=True)
res = model.invoke(
    [
        SystemMessage(content="你是一个乐于助人的AI助手"),
        HumanMessage(content="你好啊"),
    ]
)
print(res.content)
1
2
3
4
5
6
7
8
9
10
11
12
13

你好！很高兴见到你。我是 Gemini，是 Google 开发的多模态 AI 语言模型。
1

大语言模型

from langchain_google_genai import GoogleGenerativeAI

# 使用LLM对话
GOOGLE_API_KEY = ""
llm = GoogleGenerativeAI(model="gemini-pro", google_api_key=GOOGLE_API_KEY)
print(
    llm.invoke(
        "Python 作为编程语言的一些优点和缺点是什么?"
    )
)
1
2
3
4
5
6
7
8
9
10

使用Chain

from langchain_core.prompts import PromptTemplate

# 提示模板
template = """
问题: {question}

答：让我们一步一步来思考
"""
# 创建模板实例
prompt = PromptTemplate.from_template(template)
# 使用chain
chain = prompt | llm
# 调用
question = "2+2是多少?"
print(chain.invoke({"question": question}))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

流式处理和批处理

for chunk in llm.stream("Write a limerick about LLMs."):
    print(chunk.content)
1
2

results = llm.batch(
    [
        "What's 2+2?",
        "What's 3+5?",
    ]
)
for res in results:
    print(res.content)
1
2
3
4
5
6
7
8

视觉消息对话

from langchain_core.messages import HumanMessage
from langchain_google_genai import ChatGoogleGenerativeAI

llm = ChatGoogleGenerativeAI(model="gemini-pro-vision")

message = HumanMessage(
    content=[
        {
            "type": "text",
            "text": "这张图片中有什么?",
        },
        {"type": "image_url", "image_url": "https://picsum.photos/seed/picsum/200/300"},
    ]
)
res = llm.invoke([message])
# 图片中显示的是一座被白雪覆盖的山峰，山峰在日落时分被染成了粉红色。
print(res.content)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

文本嵌入

谷歌模型使用嵌入模型也非常简单，如下所示

from langchain_google_genai import GoogleGenerativeAIEmbeddings

# 加载内嵌向量模型
embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")

# 向量化
vectors = embeddings.embed_documents(
    [
        "Today is Monday",
        "Today is Tuesday",
        "Today is April Fools day",
    ]
)
print(len(vectors), len(vectors[0]))

# 向量查询
vector = embeddings.embed_query("hello, world!")
print(vector[:5])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

调用Hugging Face模型

环境准备

访问：HuggingFace，在个人设置中心，创建一个API Token

安装以下相关库

pip install text_generation langchainhub  
1

在程序中设置API Token

# 导入HuggingFace API Token
import os
os.environ['HUGGINGFACEHUB_API_TOKEN'] = 'HuggingFace API Token'
1
2
3

在命令行中运行 huggingface-cli login，设置API Token。

(langchain) PS C:\WorkSpace\langchain> huggingface-cli login

    _|    _|  _|    _|    _|_|_|    _|_|_|  _|_|_|  _|      _|    _|_|_|      _|_|_|_|    _|_|      _|_|_|  _|_|_|_|
    _|    _|  _|    _|  _|        _|          _|    _|_|    _|  _|            _|        _|    _|  _|        _|
    _|_|_|_|  _|    _|  _|  _|_|  _|  _|_|    _|    _|  _|  _|  _|  _|_|      _|_|_|    _|_|_|_|  _|        _|_|_|
    _|    _|  _|    _|  _|    _|  _|    _|    _|    _|    _|_|  _|    _|      _|        _|    _|  _|        _|
    _|    _|    _|_|      _|_|_|    _|_|_|  _|_|_|  _|      _|    _|_|_|      _|        _|    _|    _|_|_|  _|_|_|_|

    A token is already saved on your machine. Run `huggingface-cli whoami` to get more information or `huggingface-cli logout` if you want to log out.        
    Setting a new token will erase the existing one.
    To login, `huggingface_hub` requires a token generated from https://huggingface.co/settings/tokens .
Token can be pasted using 'Right-Click'.
Enter your token (input will not be visible):
Token is valid (permission: write).
Your token has been saved in your configured git credential helpers (manager).
Your token has been saved to C:\Users\Admin\.cache\huggingface\token
Login successful
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

聊天模型

利用HuggingFaceEndpoint或HuggingFaceHub集成来实例化LLM，然后与LangChain的聊天消息抽象进行交互。

1.HuggingFaceHub
HuggingFaceHub将在LangChain的0.2.0版本弃用，但目前任然支持。

import os
os.environ["GOOGLE_API_KEY"] = ''

from langchain_community.llms import HuggingFaceHub

llm = HuggingFaceHub(
    repo_id="HuggingFaceH4/zephyr-7b-beta",
    task="text-generation",
    model_kwargs={
        "max_new_tokens": 30,
        "top_k": 1,
        "temperature": 0.1,
        "repetition_penalty": 1.03,
    },
)

print(llm.invoke("你好，你是谁？"))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

你好，你是谁？

你好，我是小明。

请问，你在做什么？

我在学习汉语。
1
2
3
4
5
6
7

2.HuggingFaceEndpoint
HuggingFaceEndpoint类是LangChain现在及未来主要推荐的库

from langchain_community.llms.huggingface_endpoint import HuggingFaceEndpoint

ENDPOINT_URL = "HuggingFaceH4/zephyr-7b-beta"
HF_TOKEN = ""

llm = HuggingFaceEndpoint(
    endpoint_url=ENDPOINT_URL,
    max_new_tokens=30,
    top_k=2,
    top_p=0.95,
    typical_p=0.95,
    temperature=0.01,
    repetition_penalty=1.03,
    huggingfacehub_api_token=HF_TOKEN
)

print(llm.invoke("你好，你是谁？"))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

大语言模型

Hugging Face模型中心托管了超过12万个模型、2万个数据集和5万个演示应用程序(Spaces)，所有这些都是开源和公开的。人们可以在该在线平台上轻松协作并共同构建机器学习。这些资源可以通过本地管道包装器从LangChain调用，也可以通过HuggingFaceHub类调用托管的推理端点。

使用transformers库，需要额外安装

pip install transformers==4.39.3 accelerate==0.29.1  torch
1

from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline

hf = HuggingFacePipeline.from_model_id(
    model_id="gpt2",
    task="text-generation",
    pipeline_kwargs={"max_new_tokens": 10},
)

print(hf.invoke("你好，你是谁？"))
1
2
3
4
5
6
7
8
9

transformers也可以通过直接传入现有管道来加载

# 导入 HuggingFacePipeline 类和相关模块
from langchain_community.llms.huggingface_pipeline import HuggingFacePipeline
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline

# 定义 GPT-2 模型的标识
model_id = "gpt2"

# 加载 GPT-2 模型的 tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_id)

# 加载 GPT-2 模型本身
model = AutoModelForCausalLM.from_pretrained(model_id)

# 创建一个文本生成的 pipeline，最多生成 10 个新 token
pipe = pipeline("text-generation", model=model, tokenizer=tokenizer, max_new_tokens=10)

# 初始化 HuggingFacePipeline 对象，传入文本生成的 pipeline
hf = HuggingFacePipeline(pipeline=pipe)

# 打印
print(llm.invoke("你好啊!"))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

使用消息对象

from langchain.schema import (
    HumanMessage,
    SystemMessage,
)

messages = [
    SystemMessage(content="你是一个乐于助人的助手"),
    HumanMessage( content="你好，你是谁?"),
]

res = llm.invoke(messages)
print(res)
1
2
3
4
5
6
7
8
9
10
11
12

Token has not been saved to git credential helper. Pass `add_to_git_credential=True` if you want to set the git credential as well.
Token is valid (permission: write).
Your token has been saved to C:\Users\Admin\.cache\huggingface\token
Login successful

Assistant: 我是一个智能语音助手，我可以为您提供各种信息和帮助。
1
2
3
4
5
6