无限可能LangChain——构建聊天机器人

最新推荐文章于 2024-07-06 12:03:33 发布
最新推荐文章于 2024-07-06 12:03:33 发布
阅读量932 收藏 22
点赞数 17
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_31862487/article/details/139402218
版权

概览

我们将介绍一个如何设计和实现LLM驱动的聊天机器人的示例。这个聊天机器人将能够进行对话并记住以前的交互。

请注意，我们构建的聊天机器人只使用语言模型进行对话。您可能还在寻找其他几个相关概念：

  • 对话式RAG：在外部数据源上实现聊天机器人体验
  • 代理：构建可以执行操作的聊天机器人

本教程将介绍基础知识，对于这两个更高级的主题将会有所帮助。

概念

以下是我们将要使用的一些高级组件：

  • Chat Models : 聊天机器人界面是基于消息而不是原始文本的，因此最适合使用 Chat Models 而不是文本LLMs。
  • Prompt Templates : 简化了组装提示的过程，包括默认消息、用户输入、聊天历史和（可选）额外的检索上下文。
  • Chat History : 允许聊天机器人“记住”过去的交互，并在回答后续问题时考虑它们。
  • 使用 LangSmith 调试和跟踪应用程序。

我们将介绍如何将上述组件组合在一起，创建一个强大的对话式聊天机器人。

安装

参考前面文档： 《无限可能LangChain——开启大模型世界》 《无限可能LangChain——构建一个简单的LLM应用程序》

快速入门

首先，让我们直接使用模型。ChatModels 是LangChain 的“可运行”实例，这意味着它们提供了一个与之交互的标准接口。为了简单调用模型，我们可以将一个消息列表传递给 .invoke 方法。

from langchain_community.llms import Tongyi
from langchain_core.messages import HumanMessage

# 使用 Tongyi LLM，并设置温度为 1，代表模型会更加随机，但也会更加不确定
llm = Tongyi(temperature=1)

# 将一个消息列表传递给 .invoke 方法
result = llm.invoke([HumanMessage(content="你好，我是小明")])
print(result)

API Reference:HumanMessage

运行结果： image.png

但是模型本身没有任何状态概念。例如，如果您提出一个后续问题：

from langchain_community.llms import Tongyi
from langchain_core.messages import HumanMessage

# 使用 Tongyi LLM，并设置温度为 1，代表模型会更加随机，但也会更加不确定
llm = Tongyi(temperature=1)

# 将一个消息列表传递给 .invoke 方法
result = llm.invoke([HumanMessage(content="你好，我是小明")])
print(result)

# 模型本身没有任何状态记录，再次提问
result = llm.invoke([HumanMessage(content="我的姓名是什么?")])
print(result)

image.png

image.png

可以看出这时大模型完全没法正常对话，明明前一句告诉它我是小明，后一句它说我是李华。

我们可以看到它没有将之前的对话转化为上下文，并且无法回答这个问题。这样会导致糟糕的聊天机器人体验！

让我们来看一下 LangSmith 跟踪的示例 ： 对话1 对话2

为了解决这个问题，我们需要将整个对话历史传递给模型。让我们看看当我们这样做时会发生什么：

from langchain_community.llms import Tongyi
from langchain_core.messages import HumanMessage,AIMessage

# 使用 Tongyi LLM，并设置温度为 1，代表模型会更加随机，但也会更加不确定
llm = Tongyi(temperature=1)

# 将全部消息列表传递给 .invoke 方法
result = llm.invoke([
                    HumanMessage(content="你好，我是小明"),
                    AIMessage(content="你好！很高兴认识你。你在想什么呢？"),
                    HumanMessage(content="我的姓名是什么?")
                ])
print(result)

API Reference:AIMessage

运行结果： image.png LangSmith 跟踪的示例：对话日志

现在我们可以看到我们得到了一个很好的回答！

这是支持聊天机器人进行对话互动能力的基本思想。那么我们如何最好地实现呢？

历史对话

我们可以使用一个消息历史类来封装我们的模型，使其具有状态。这将跟踪模型的输入和输出，并将它们存储在某个数据存储中。未来的交互将加载这些消息，并作为输入的一部分传递给链条。让我们看看如何使用它！

首先，让我们确保安装了langchain-community，因为我们将在其中使用一个集成来存储消息历史记录。

pip install langchain_community

之后，我们可以导入相关的类并设置我们的链，它将包装模型并添加这个消息历史记录。这里的一个关键部分是我们传递给 get_session_history 的函数。这个函数应该接受一个session_id并返回一个消息历史记录对象。这个session_id用于区分不同的对话，并应该作为调用新链条时的配置的一部分传递进去（我们将展示如何做到这一点）。

from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

store = {}


def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]


with_message_history = RunnableWithMessageHistory(model, get_session_history)

API Reference:ChatMessageHistory | BaseChatMessageHistory | RunnableWithMessageHistory

现在我们需要创建一个配置，每次传递给可运行的时候使用。这个配置包含的信息不是直接的输入的一部分，但仍然很有用。在这种情况下，我们想要包含一个session_id。它应该是这样的：

config = {"configurable": {"session_id": "abc2"}}

完整代码：

from langchain_community.llms import Tongyi
from langchain_core.messages import HumanMessage
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

store = {}

def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

# 使用 Tongyi LLM，并设置温度为 1，代表模型会更加随机，但也会更加不确定
llm = Tongyi(temperature=1)

# 历史消息
with_message_history = RunnableWithMessageHistory(llm, get_session_history)

# 对话1
config = {"configurable": {"session_id": "abc2"}}

# 将一个消息列表传递给 .invoke 方法
response1 = with_message_history.invoke([HumanMessage(content="你好，我是小明")], config=config)
print(response1)

# 模型本身没有任何状态记录，再次提问
response2 = with_message_history.invoke([HumanMessage(content="我的姓名是什么?")], config=config)
print(response2)

太棒了！我们的聊天机器人现在可以记住我们的信息了。但是笔者亲测，目前有报错：Error in RootListenersTracer.on_llm_end callback: KeyError('message')。

官方文档也有人提出 issues： https://github.com/langchain-ai/langchain/issues/22060 期待后续解决。然后在下面的【提示模版】的完整代码就不会报该错误了，也算一种解法。

image.png

如果我们更改配置以引用不同的session_id，我们可以看到它会重新开始对话。

config = {"configurable": {"session_id": "abc3"}}

response = with_message_history.invoke(
    [HumanMessage(content="你的名字是什么")],
    config=config,
)

但是，我们总是可以回到最初的对话（因为我们将其持久化在数据库中）

config = {"configurable": {"session_id": "abc2"}}

response = with_message_history.invoke(
    [HumanMessage(content="你好，我是小强")],
    config=config,
)

这就是我们如何支持聊天机器人与许多用户进行对话！

目前，我们所做的只是在模型周围添加了一个简单的持久化层。我们可以通过添加提示模板来使其更复杂和个性化。

提示模板

提示模板有助于将原始用户信息转换为LLM可以处理的格式。在这种情况下，原始用户输入只是一个消息，我们将其传递给LLM。现在让我们稍微复杂一些。首先，让我们添加一个带有一些自定义指示的系统消息（但仍然以消息作为输入）。接下来，我们将添加除了消息之外的更多输入。

首先，让我们添加一个系统消息。为此，我们将创建一个ChatPromptTemplate。我们将利用MessagesPlaceholder 来传递所有的消息。

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# 提示模板
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "你是一个有用的助手。尽你所能回答所有问题。",
        ),
        MessagesPlaceholder(variable_name="messages"),
    ]
)

# 使用 Tongyi LLM，并设置温度为 1，代表模型会更加随机，但也会更加不确定
llm = Tongyi(temperature=1)

chain = prompt | llm

API Reference:ChatPromptTemplate | MessagesPlaceholder

请注意，这稍微改变了输入类型-我们不再传递一个消息列表，而是传递一个字典，其中包含一个名为messages的键，其值是一个消息列表。

# 将一个消息列表传递给 .invoke 方法
response1 = with_message_history.invoke({"messages": [HumanMessage(content="你好，我是小明")]}, config=config)
print(response1)

打印输出： image.png

现在我们可以将其与之前相同的消息历史对象包装在一起：

# 历史消息
with_message_history = RunnableWithMessageHistory(chain, get_session_history)

# 对话1
config = {"configurable": {"session_id": "abc2"}}

# 将一个消息列表传递给 .invoke 方法
response1 = with_message_history.invoke(
    {"messages": [HumanMessage(content="你好，我是小明")], "language":"english"}, 
    config=config
)
print(response1)

# 模型有历史聊天记录，再次提问
response2 = with_message_history.invoke(
    {"messages": [HumanMessage(content="我的姓名是什么?")], "language":"english"}, 
    config=config
)

完整代码：

from langchain_community.llms import Tongyi
from langchain_core.messages import HumanMessage
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# 提示模板
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "你是一个有用的助手。尽你所能回答所有问题。",
        ),
        MessagesPlaceholder(variable_name="messages"),
    ]
)

# 历史会话存储
store = {}

# 获取会话历史
def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

# 使用 Tongyi LLM，并设置温度为 1，代表模型会更加随机，但也会更加不确定
llm = Tongyi(temperature=1)

# 构建链式调用
chain = prompt | llm

# 历史消息
with_message_history = RunnableWithMessageHistory(chain, get_session_history)

# 对话1
config = {"configurable": {"session_id": "abc2"}}

# 将一个消息列表传递给 .invoke 方法
response1 = with_message_history.invoke({"messages": [HumanMessage(content="你好，我是小明")]}, config=config)
print(response1)

# 模型有历史聊天记录，再次提问
response2 = with_message_history.invoke({"messages":[HumanMessage(content="我的姓名是什么?")]}, config=config)
print(response2)

LangSmith 跟踪的示例：对话日志 image.png

太棒了！现在让我们把提示变得更复杂一点。让我们假设提示模板现在看起来像这样：

# 提示模板
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "你是一个有用的助手。尽你所能用{language}回答所有问题。",
        ),
        MessagesPlaceholder(variable_name="messages"),
    ]
)

# 使用 Tongyi LLM，并设置温度为 1，代表模型会更加随机，但也会更加不确定
llm = Tongyi(temperature=1)

# 构建链式调用
chain = prompt | llm

请注意，我们在提示符中添加了一个新的 language 输入。我们现在可以调用链并传入我们选择的语言。 并且让我们将这个更复杂的链包装在一个消息历史类中。这次，因为输入中有多个键，我们需要指定正确的键来保存聊天记录。

from langchain_community.llms import Tongyi
from langchain_core.messages import HumanMessage
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# 提示模板
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "你是一个有用的助手。尽你所能用{language}回答所有问题。",
        ),
        MessagesPlaceholder(variable_name="messages"),
    ]
)

# 历史会话存储
store = {}

# 获取会话历史
def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

# 使用 Tongyi LLM，并设置温度为 1，代表模型会更加随机，但也会更加不确定
llm = Tongyi(temperature=1)

# 构建链式调用
chain = prompt | llm

# 历史消息
with_message_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="messages",
)

# 对话1
config = {"configurable": {"session_id": "abc2"}}

# 将一个消息列表传递给 .invoke 方法
response1 = with_message_history.invoke(
    {"messages": [HumanMessage(content="你好，我是小明")], "language":"english"}, 
    config=config
)
print(response1)

# 模型有历史聊天记录，再次提问
response2 = with_message_history.invoke(
    {"messages": [HumanMessage(content="我的姓名是什么?")], "language":"english"}, 
    config=config
)
print(response2)

为了帮助您了解内部发生了什么，请查看LangSmith跟踪（第二句回复又变回了中文，呵呵） image.png

管理对话历史

构建聊天机器人时要理解的一个重要概念是如何管理对话历史。如果不加管理，消息列表将无限增长，并可能溢出LLM的上下文窗口。因此，添加一个限制您传入的消息大小的步骤非常重要。

重要的是，您将希望在提示模板之前但在从消息历史记录加载以前的消息之后执行此操作。

我们可以通过在提示符前面添加一个简单的步骤来适当地修改messages键，然后将新链包装在消息历史类中。首先，让我们定义一个函数来修改传入的消息。让我们使它选择k最近的消息。然后我们可以通过在开始时添加它来创建一个新链。

from langchain_core.runnables import RunnablePassthrough


# k=10 则无法记得姓名是什么，k=20 则可以记得
def filter_messages(messages, k=20):
    return messages[-k:]


chain = (
    RunnablePassthrough.assign(messages=lambda x: filter_messages(x["messages"]))
    | prompt
    | llm
)

API Reference:RunnablePassthrough

现在让我们试试看！如果我们创建一个超过10条消息的消息列表，我们可以看到它不再记得早期消息中的信息。

messagesList = [
    HumanMessage(content="你好，我是小明"),
    AIMessage(content="你好!"),
    HumanMessage(content="我喜欢香草冰淇淋"),
    AIMessage(content="好的"),
    HumanMessage(content="2 + 2 等于几"),
    AIMessage(content="4"),
    HumanMessage(content="谢谢"),
    AIMessage(content="不用谢!"),
    HumanMessage(content="正玩得开心么?"),
    AIMessage(content="是的!"),
]
# 模型有历史聊天记录，再次提问
response = with_message_history.invoke(
    {"messages": messagesList + [HumanMessage(content="我的姓名是什么?")], "language":"english"}, 
    config=config
)
print(response)

打印输出： image.png

但如果我们询问最近10条信息中的信息，它仍然记得。

response = chain.invoke(
    {
        "messages": messages + [HumanMessage(content="what's my fav ice cream")],
        "language": "English",
    }
)
response.content

打印输出： image.png

现在让我们将其包装在消息历史记录中，完整代码：

from langchain_community.llms import Tongyi
from langchain_core.messages import HumanMessage,AIMessage
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables import RunnablePassthrough

# k=10 则无法记得姓名是什么，k=20 则可以记得
def filter_messages(messages, k=10):
    return messages[-k:]


# 提示模板
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "你是一个有用的助手。尽你所能用{language}回答所有问题。",
        ),
        MessagesPlaceholder(variable_name="messages"),
    ]
)

# 历史会话存储
store = {}

# 获取会话历史
def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

# 使用 Tongyi LLM，并设置温度为 1，代表模型会更加随机，但也会更加不确定
llm = Tongyi(temperature=1)

# 构建链式调用
chain = (
    RunnablePassthrough.assign(messages=lambda x: filter_messages(x["messages"]))
    | prompt
    | llm
)

# 历史消息
with_message_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="messages",
)

# 对话1
config = {"configurable": {"session_id": "abc2"}}

messagesList = [
    HumanMessage(content="你好，我是小明"),
    AIMessage(content="你好!"),
    HumanMessage(content="我喜欢香草冰淇淋"),
    AIMessage(content="好的"),
    HumanMessage(content="2 + 2 等于几"),
    AIMessage(content="4"),
    HumanMessage(content="谢谢"),
    AIMessage(content="不用谢!"),
    HumanMessage(content="正玩得开心么?"),
    AIMessage(content="是的!"),
]

# 模型有历史聊天记录，再次提问
response1 = with_message_history.invoke(
    {"messages": messagesList + [HumanMessage(content="我的姓名是什么?")], "language":"english"}, 
    config=config
)
print(response1)

response1 = with_message_history.invoke(
    {"messages": messagesList + [HumanMessage(content="我喜欢的冰淇淋是什么?")], "language":"english"}, 
    config=config
)
print(response1)

如果你看一下LangSmith，你可以在LangSmith跟踪中看到到底发生了什么 LangSmith trace

image.png

流

现在我们有了一个功能聊天机器人。然而，聊天机器人应用程序的一个真正重要的用户体验考虑是流式传输。LLM有时需要一段时间才能响应，因此为了改善用户体验，大多数应用程序都会在生成每个令牌时流式传输。这允许用户看到进度。

这其实超级容易做到！

所有链都公开了一个.stream方法，使用消息历史记录的链也不例外。我们可以简单地使用该方法来获取流响应。

from langchain_community.llms import Tongyi
from langchain_core.messages import HumanMessage,AIMessage
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables import RunnablePassthrough

# k=10 只保留最近的10条消息
def filter_messages(messages, k=10):
    return messages[-k:]


# 提示模板
prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "你是一个有用的助手。尽你所能用回答所有问题。",
        ),
        MessagesPlaceholder(variable_name="messages"),
    ]
)

# 历史会话存储
store = {}

# 获取会话历史
def get_session_history(session_id: str) -> BaseChatMessageHistory:
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

# 使用 Tongyi LLM，并设置温度为 1，代表模型会更加随机，但也会更加不确定
llm = Tongyi(temperature=1)

# 构建链式调用
chain = (
    RunnablePassthrough.assign(messages=lambda x: filter_messages(x["messages"]))
    | prompt
    | llm
)

# 历史消息
with_message_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="messages",
)

# 对话1
config = {"configurable": {"session_id": "abc2"}}

# 模型有历史聊天记录，再次提问
for r in  with_message_history.stream(
    {"messages":   [HumanMessage(content="请讲一个极简的笑话给我听")]}, 
    config=config
):print(r, end="|")

image.png

如果你看一下LangSmith，你可以在LangSmith跟踪中看到到底发生了什么 LangSmith trace image.png

小结

本节我们学习了 Chat Models 、Prompt Templates、Chat History ，是非常有趣和值得去扩展的，快去实践一下吧，创造自己的聊天机器人搭子。

后续学习 如果你想深入了解细节，一些值得学习的内容是：

欢迎关注微信公众号【千练极客】，尽享更多干货文章！ qrcode_for_gh_e39063348296_258.jpg

本文由博客一文多发平台 OpenWrite 发布！

千练极客
关注
  • 17
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用LangChain开源框架实现知识机器人
Climbman的博客
07-30 1618
Large Language Models (LLMs)在2020年OpenAI 的 GPT-3 的发布而进入世界舞台。从那时起，他们稳步增长进入公众视野。众所周知 OpenAI 的 API 无法联网，所以大家如果想通过它的API实现联网搜索并给出回答、总结 PDF 文档、基于某个 Youtube 视频进行问答等等的功能肯定是无法实现的。所以，我们来介绍一个非常强大的第三方开源库：LangChain。LangChain 是一个用于开发由语言模型驱动的应用程序的框架。
无限可能LangChain——开启大模型世界
JackWu1024
06-01 841
大语言模型是一种人工智能模型，通常使用深度学习技术（如神经网络）来理解和生成人类语言。这些模型拥有非常多的参数，可以达到数十亿甚至更多，使得它们能够处理高度复杂的语言模式。我们可以将大语言模型视为一个巨大的预测机器，其训练过程基于“猜词”任务：给定一段文本的开头，模型需要预测下一个词是什么。通过大量的训练数据（如互联网上的文本），模型试图理解词语和词组的用法和含义，以及它们如何组合形成意义。通过不断学习和调整参数，模型的预测能力变得越来越准确。
无限可能LangChain——概念指南之架构
JackWu1024
06-16 1013
本节包含对 LangChain 关键部分的介绍。
【NLP】LangChain 如何构建自定义知识聊天机器人
sikh_0529的博客
09-04 619
现在，解释这部分内容将会很广泛，所以这里有一个简单的例子，说明如何在 LangChain 中使用 Python 代理来解决一个简单的数学问题。为了与我们的法学硕士进行交互，我们将实例化 OpenAI 的 GPT 模型的包装器。在本文中，我将向您介绍 LangChain，并向您展示如何将其与 OpenAI 的 API 结合使用来创建这些改变游戏规则的工具。但它真正的亮点在于将其与前面讨论的矢量存储结合使用。剩下要做的就是结合我们所学到的知识来创建我们的特定用例——为我们提供专门的人工智能“代理”。
AI中台——智能聊天机器人平台的架构与应用
03-03
分享了AI中台的具体实施路径，并重点介绍了AI中台的智能产品——智能聊天机器人平台，包括智能聊天机器人平台的背景理念、设计思想、技术架构和应用场景，该平台能提供什么样的能力，以及它如何快速地支持业务方，...
Streamlit UI 的自定义代理医疗聊天机器人的 GitHub 存储库！ LangChain自定义代理聊天机器人
02-18
LangChain自定义代理聊天机器人，具有Streamlit UI 网站互动：聊天机器人使用最新版本的LangChain与各种网站进行交互并从中提取信息，提供有见地的响应。 大型语言模型集成：兼容 GPT-4、Mistral、Llama2 和 ollama ...
AI中台——智能聊天机器人平台.docx
09-20
AI 中台——智能聊天机器人平台 AI 中台是一种集成的智能服务平台，为各种智能设备和机器人提供底层技术支持，使其能够实现语音识别、图像处理、自然语言处理等功能。本文将深入探讨中台的概念、发展历程、应用场景...
AI中台——智能聊天机器人平台.pdf
10-27
AI中台——智能聊天机器人平台.pdf
Ansys Zemax｜场曲跟畸变图的前世今生
ueotek的博客
07-02 403
这里的y和z坐标和方向余弦是（Hx, Hy, Px, Py）=（X, X, 0 ,0）和（Hx, Hy, Px, Py）=（X, X, 0 ,0.001），在光线追迹像面的前一个平面的 z坐标和方向余弦。OpticStudio通过在X和Y方向（弧矢和子午方向）的傍轴光线追踪确定近轴图像平面的Z坐标，并测量该近轴焦平面与系统图像平面的Z坐标之间的距离。使用附件中的样本文件，近轴像面的全局Z坐标与视场0处的像面位置之差与场曲和畸变图中的的Tan Shift相同。近轴像面的定义是以下两个光线交点的全局Z坐标。
Java基础:爬虫
weixin_65752158的博客
07-04 872
Pattern:表示正则表达式Matcher:文本匹配器，作用按照正则表达式的规则去读取字符串，从头开始读取。在大串中去找符合匹配规则的子串。通过Pattern p = Pattern.compile("正则表达式");获得 通过Matcher m = p.matcher(str);获得 (m要在str中找符合p规则的小串)其中, m为Matcher对象, p为正则表达式规则, str为要验证的字符串. boolean b = m.find(); 表示拿着文本匹配器从头开始读取，寻找是否有
使用Python实现深度学习模型：序列建模与生成模型的博客教程
Echo_Wish的博客
07-02 1185
本文介绍了使用Python实现深度学习模型的序列建模和生成模型的步骤。我们详细说明了每个步骤，并提供了相应的代码示例。通过学习本文，您将能够使用Python构建和训练序列建模和生成模型，并生成新的序列数据。希望本文对您有所帮助！如果您有任何问题或建议，请随时提出。
Django学习第四天
qq_43580271的博客
07-04 429
UserEditModelForm类继承了BootStrapModelForm类的方法，BootStrapModelForm继承了forms.ModelForm的方法所以使用继承能够更好封装代码功能。ModelForm引入时间样式（自动生成了id为id_create_time)django自动帮我们把session功能定义好了，使用只需要这样一个语句。封装每部分的功能，拆分到每个模块中去。在html中增加属性的方法1。在html中增加属性的方法2。在html中增加属性的方法3。在用户列表页面使用分页功能。
Java高级重点知识点-19-Lambda
m0_72926194的博客
07-02 509
本文主要是讲解了如何使用lambda表达式来简介代码开发，同时讲解了函数式编程思想，该思想主要的是体现做什么，而不是怎么做。
【Python进阶】函数的扩展
最新发布
weixin_52854743的博客
07-06 749
python函数的补充，包括函数的嵌套调用、函数的变量作用域、多种参数、拆包和交换变量值、引用和匿名函数
并发编程面试题1
搬砖的小熊猫的博客
07-03 935
单例模式中的懒汉机制会有有序性问题。DCL（Double-Checked Locking）方式存在指令重排问题，可能导致NullPointerException。在Java编译时，JIT会优化指令顺序，提升执行效率。在CPU层面，也会对指令进行重新排序，提升执行效率。这种指令调整在特殊操作上可能会导致问题。
每日一道算法题 彩灯装饰记录 I
weixin_65816128的博客
07-05 300
【代码】每日一道算法题 彩灯装饰记录 I。
Python Tkinter手搓俄罗斯方块
甜盐的博客
07-03 546
俄罗斯方块是一个经典的电子游戏，风靡全球。下面我们一步一步地使用Python和Tkinter库制作一个简易的俄罗斯方块游戏。
用python构建人功能聊天机器人的模型
05-25
要构建一个人工智能聊天机器人，我们可以使用Python中的自然语言处理（NLP）和机器学习技术。下面是一个基本的聊天机器人的构建模型： 1. 收集数据：要训练机器人，我们需要大量的对话数据。您可以使用公共的聊天数据集，如Cornell Movie Dialogs Corpus、Ubuntu Dialogue Corpus等，也可以自己构建数据集。 2. 数据预处理：对于NLP任务，数据预处理是非常重要的。我们需要进行分词、去除停用词、词干提取等操作，并将数据转换成模型可用的数字表示形式。 3. 训练模型：我们可以使用深度学习模型，如循环神经网络（RNN）和变压器（Transformer）来训练聊天机器人。这些模型可以在大量的数据上进行训练，并且可以生成与人类对话相似的响应。 4. 部署模型：在模型训练完成后，我们可以将其部署到一个Web应用程序或聊天应用程序中。可以使用Python中的Flask、Django等框架来构建Web应用程序，或使用Telegram、微信等聊天应用程序的API进行开发。 5. 优化和改进：聊天机器人的性能可以通过不断的优化和改进来提高。可以使用反馈机制来改善机器人的回答，或训练模型以处理更多的语言和对话场景。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值