实现知识库问答机器人 langchain + LLM + Embeddings (比Langchain-Chatchat更智能)

【LangChain系列文章】4. 向量数据库Vector Stores 向量数据库Vector Stores 和 embeddings介绍 及简单的使用 阅读详情

一、前言

模型既然会胡说八道那为啥不让模型在判断一下自己输出的是否正确呢?🤔
于是我产生了一个想法:提供一些条件让模型自己判断自己的推理是否正确✨

本文以实现一个知识库为例,但是和其他的知识库有区别。 目前流行知识库如 Langchain-Chatchat 只能回答检索到的内容,但是对内容的整理和总结的能力就很弱了。还有对一些上下文不是很连贯的内容推理也比较弱,比如招标文件等这种模板文件,多个文件格式都一样。只有标题和一些字段不同。

总结就是要实现能检索知识库和聊天并行。

下文代码将使用 python3 进行编码。并且在 google 实验室中进行。

二、实现思路

分为知识库整理和推理两个步骤:

graph TD
文件内容 --> 加载文件
加载文件 --> txt文件
加载文件 --> 图片文件
加载文件 --> doc
加载文件 --> ...
txt文件 --> langchainc拆分文本
图片文件 --> 其他处理
doc --> 其他处理
... --> 其他处理
其他处理 --> langchainc拆分文本
langchainc拆分文本 --> Embeddings文本转向量
Embeddings文本转向量 --> 存储到向量库

用户输入 --> LLM对语句补全;
LLM对语句补全 --> 补全是否合理;
补全是否合理  -->|合理| LLM获取Embeddings语义;  
补全是否合理 -->|不合理| LLM对语句补全;
LLM获取Embeddings语义 --> 语义是否合理;
语义是否合理 -->|合理| 向量库检索;
语义是否合理 -->|不合理| LLM获取Embeddings语义;
向量库检索 --> 检索内容+用户输入
检索内容+用户输入 --> LLM推理
LLM推理 --> 结果是否合理
结果是否合理 -->|合理| 输出;
结果是否合理 -->|不合理| LLM获取Embeddings语义;

三、依赖库下载:

  1. langchain 用来调用 llm 和 embeddings
  2. chromadb 向量库
  3. gradio 超级方便的写 Ai 用的 UI 库
  4. sentence_transformers HF提供的(调用抱脸的方法来使用模型)
!pip install --upgrade --quiet  langchain langchain-community langchainhub chromadb bs4
!pip install sentence_transformers
!pip install gradio

四、模型下载

  1. text2vec-large-chinese (huggingface.co/GanymedeNil…)
  2. openchat (huggingface.co/openchat/op…)

根据测试,上面两个模型在中文环境下比较好用,而且部署 openchat (7B) 只需要使用一张 3090 即可。 text2vec-large-chinese 用 gpu 的情况下 3G 左右的显存就够了。

因为使用的免费版的实验室,所以提供的 GPU 跑不起来这个模型。所以模型使用官方的 api,只有 embeddings 在实验室环境中跑。

openchat 在 Hugging Face 也提供了接口,但是测试发现返回的内容过长会被截断,也就是不完整,所以只能去官网案例中找一个接口用(下文会提供)。

!git clone https://huggingface.co/GanymedeNil/text2vec-large-chinese

五、依赖引入

先直接在顶部把要用到的依赖全部引入。

import os
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain import hub

from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter, RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain_community.document_loaders import TextLoader  

from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.llms import HuggingFaceHub
import gradio as gr

import re
import bs4
import requests
import random

六、openchat 模型接口调用

上面说了实验室环境中没法直接搭建 openchat 环境,所以只能写法方法调用线上接口了。 这个代码比较简单,直接使用 requests 来调用接口,传入对话内容和温度参数。

# @title openchat 模型接口调用函数 
def openchatGen(messages, prompt = " ", temperature = 0.5): 
    API_URL = "https://openchat.team/api/chat"

    def query(payload):
        response = requests.post(
            API_URL,
            #  headers={},
            json=payload
        )
        # print(response)
        return response.text


    output = query({
        "key": "",
        "prompt": prompt, # 接口未处理这个参数
        "temperature": temperature,
        "model": {
            "id": "openchat_v3.2_mistral",
            # "id": "openchat_3",
            "name": "OpenChat Aura",
            "maxLength": 24576,
            "tokenLimit": 8192
        },
        "messages": messages or [
            # {  "role": "user",  "content": "xxx",  }
            # {  "role": "assistant",  "content": "xxx",  }
            # {  "role": "system",  "content": "xxx",  }
        ]
    })
    return output

# 普通调用
openchatGen_test1 = openchatGen([
    {"role": "user",  "content": "你好"}
])
print(openchatGen_test1)

# prompt 设置 | 多轮对话
openchatGen_test2 = openchatGen([
        {"role": "user",  "content": "你的名字叫大白,你喜欢吃饭。记住了吗?"},
        {"role": "assistant",  "content": "好的,我记住了"},
        {"role": "user",  "content": "你叫什么名字?"}
])
print(openchatGen_test2)


效果如下 image.png

七、加载文档

测试用文学作品形式的文档体验会很好,但是工作中那种文本会比较少。所以这里直接使用上下文都不怎么连贯的招标数据。

本文中文档使用 20 条招标数据。数据如下格式。

注:这些数据都是公开的,不是隐私数据。 image.png

直接调用 langchain 提供的加载文档和拆分文档的方法,非常的简单。只是注意参数需要调好即可。代码如下:

# @title 加载文档 
loader = TextLoader("./test.txt")
document = loader.load()
# 文档拆分
text_splitter = CharacterTextSplitter(  
    separator="",
    chunk_size=124,
    chunk_overlap=0, 
    length_function=len,
    is_separator_regex=False,
)

org_texts = text_splitter.split_documents(document) 
 
# 竞标数据 
texts = []
for item in org_texts:
    # 去除空格
    item.page_content = item.page_content.replace(" ","").replace("   ","")
    texts.append(item)
  

八、embeddings 模型环境搭建

老手的话可以看出来这里直接调用 HF 接口可能更简单。但是文档拆太细的话调用接口次数多就会噶!

模型路径是基于 google 实验室写的,自行根据情况更改即可。

# @title embeddings 模型使用, 
# 模型有些大必须用 GPU 跑,不然会卡住 
model_path = "/content/text2vec-large-chinese"  # 根据条件改
model_kwargs = {'device': 'cuda:0'} # 用一个gpu跑,根据条件改
encode_kwargs = {'normalize_embeddings': False}
embeddings = HuggingFaceEmbeddings(
    model_name=model_path,
    model_kwargs=model_kwargs,
    encode_kwargs=encode_kwargs
)

text = "你好."
query_result = embeddings.embed_query(text)
print("emb len:", len(query_result))

测试效果
image.png

九、将文本转换为向量

还是使用 langchain 集成的向量库 Chroma 将文本转为向量数据。
检索方法下面代码中写了三种,实际上第一种默认的就够用了,当第一种效果不佳时可以尝试下另外两种。

# @title 使用 embedding engion 将 text 转换为向量
db = Chroma.from_documents(
    texts,
    embeddings,
    # 可以存起来,下次就不用做这个操作了
    # persist_directory="/content/chroma_db"
)
 
# 默认检索
retriever = db.as_retriever()

# 只搜索最匹配的一条
# retriever = db.as_retriever(search_kwargs={'k': 1})

# 稍微严格些
# retriever = db.as_retriever(
#     search_type="mmr",
#     # search_kwargs={'k': 5, 'fetch_k': 80}
#     search_kwargs={'fetch_k': 90}
# )
 

十、将用户输入转为更有利于 embeddings 检索的语句

用户和机器人对话时候往往不是以关键词的方式进行,而向量数据库是需要用到关键词的。所以需要将用户的语句中的关键词转一下,不然检索效果往往太依赖于用户的提问技巧。所以这个步骤非常有必要。

下面用 prompt 来让 llm 帮我们做这个事情。其实只要 prompt 写得准确,llm 给我们的答案还是不错的。

# @title 将用户输入转为更有利于 embeddings 检索的语句
def getAIQuestion(userQuestion): 
    # 改为使用接口方式请求
    template = """ 原始语句:{context} \n帮我转换为更适合Embedding模型检索的语句 """
    prompt = PromptTemplate(template=template, input_variables=["context"])
    prompt_text = prompt.format(context=userQuestion)
    # prompt 设置 | 多轮对话
    res = openchatGen([
            {"role": "user",  "content": "你只负责把语义转换为更适合Embedding模型检索的语句,注意不是翻译句子,并不能和用户对话。当用户语义没有问题时不做处理"},
            {"role": "assistant",  "content": "好的。"},
            {"role": "user",  "content": "原始语句:小桂子胎记在哪? \n帮我转换为更适合Embedding模型检索的语句"},
            {"role": "assistant",  "content": "小桂子胎记位置"},
            {"role": "user",  "content": "原始语句:谁是疯子? \n帮我转换为更适合Embedding模型检索的语句"},
            {"role": "assistant",  "content": "疯子的名字"},
            {"role": "user",  "content": prompt_text }
    ], temperature=0.4)
    return res

# 测试
test_arr_1 = [
    "帮我搜索一下2024年有哪些比选信息",
    "微订饮水机招标信息的联系人告诉我",
    "你好"
]

for item in test_arr_1:
    res = getAIQuestion(item)
    print(f"=== {item} -> {res}")

image.png

十一、测试向量库的检索

有了上面的 getAIQuestion 方法,现在我们来测试一下检索效果。

# @title 向量库检索测试 
questionTest = "生产性耗材的招标有吗?" 

questionTest_ai = getAIQuestion(questionTest)
print("原始:", questionTest)
print("AI:", questionTest_ai)
 
retrieved_docs_ai = retriever.invoke(questionTest_ai)

print("测试结果:", len(retrieved_docs_ai))
print("\n") 
print("\n---------------- AI ------------\n")

for item in retrieved_docs_ai:
    print(item) 


结果不是那么丰富,因为是从库里匹配出来的知识片段,还需要给 LLM 整理才行。 image.png

十二、获取一轮对话的相关性得分 返回 0 - 1 的浮点数

怎么保证 LLM 不会答非所问,这就得写另一个方法来控制了。下面这个方法对比一轮对话是否是有关联,给关联性打个分。因为直接判断是或者不是的情况并不会很准确,但是打分的话咋们自己控制一下阈值会得到很好的效果。

# @title 获取一轮对话的相关性得分 返回 0 - 1 的浮点数
# 一般大于 0.3 就有一定的相关性了
def getAIQAIS(question, answer):
    template = """
    <question>{question}</question><answer>{answer}</answer>
    """

    prompt = PromptTemplate(template=template, input_variables=["question", "answer"])
    prompt_text = prompt.format(question=question, answer=answer)
    # prompt 设置 | 多轮对话
    res = openchatGen([
            {"role": "user",  "content": "我会把一轮对话分别放到<question></question>和<answer></answer>标签中,你需要分析一下两个句子的相关性得分,第二句是不知道的意思也需要给高分,因为也算是对第一句的回答,只要两句话有关联得分就需要大于 0.5, 得分范围 0 - 1。仅仅告诉用户得分即可,不用发送其他语句。"},
            {"role": "assistant",  "content": "好的。"},
            {"role": "user",  "content": "<question>兰姨娘非常的美吗?</question><answer>是的兰姨娘很美。</answer>"},
            {"role": "assistant",  "content": "0.99"},
            {"role": "user",  "content": "<question>德先生为什么很奇怪?</question><answer>因为他是一个妖怪</answer>"},
            {"role": "assistant",  "content": "0.6"},
            {"role": "user",  "content": "<question>小米为啥打不过大米?</question><answer>我刚刚吃完饭</answer>"},
            {"role": "assistant",  "content": "0.01"},
            {"role": "user",  "content": prompt_text},
    ], temperature=0.4)
    return res

# 测试
test_arr = [
    {"question": "小明几岁了?","answer":"小明15岁了。"},
    {"question": "在做什么呢?","answer":"在吃饭。"},
    {"question": "奥特曼会打未成年的怪兽吗?","answer":"这个问题我也不知道。"},
    {"question": "小红年年第一名?","answer":"那她可真厉害!"},
    {"question": "查一下2024年有哪些名人?","answer":"今天的饭难吃极了!"},
    {"question": "明天会更好吗?","answer":"小红打了小明!"},
    {"question": "告诉我蜘蛛侠和哈利波特什么关系","answer":"我吃了一大个披萨"},
    {"question": "白素贞为什么被压在雷峰塔下面?","answer":"因为白素贞是一个妖怪!"}
]

for item in test_arr:
    res2 = getAIQAIS(item["question"], item["answer"].replace("\n", ""))
    res2t = res2.replace("\n", "").replace(" ", "")
    print(f"=== {item} -> {res2t}")


image.png

十三、获取两句话的相关性得分 返回 0 - 1 的浮点数

在知识库对话中,如果想实现对轮对话得咋们需要做两件事,

首先要明确用户提问的句子中的目标是什么?比如用户问 联系人电话号码是什么? 那需要先推理出用户问的是公司还是个人或者是哪个公司哪个人的电话号码。

完成上一步后得到的答案难道一定正确吗?不!LLM 根据一堆对话内容推理出来的结果一点也不可信。所以这时候需要保证 LLM 没有瞎说。所以需要再写一个打分函数来让第一步变的可靠。

# @title 获取两句话的相关性得分 返回 0 - 1 的浮点数
# 一般大于 0.3 就有一定的相关性了
def getAIQsIS(question1, question2):
    template = """
    <question1>{question1}</question1><question2>{question2}</question2>
    """

    prompt = PromptTemplate(template=template, input_variables=["question1", "question2"])
    prompt_text = prompt.format(question1=question1, question2=question2)
    # prompt 设置 | 多轮对话
    res = openchatGen([
            {"role": "user",  "content": "我会把两个问句分别放到<question1></question1>和<question2></question2>标签中,你需要分析一下两个句子的相关性得分,只要两句话都是问的相同的问题得分就需要大于 0.5, 得分范围 0 - 1。仅仅告诉用户得分即可,不用发送其他语句。"},
            {"role": "assistant",  "content": "好的。"},
            {"role": "user",  "content": "<question1>小红是这个项目的负责人吗?</question1><question2>京昆石太高速2024年供电(外电)线路及变压器日常维护采购项目比选的小红是这个项目的负责人吗?</question2>"},
            {"role": "assistant",  "content": "0.5"},
            {"role": "user",  "content": "<question1>比选什么时候开始?</question1><question2>比选什么时候开始?</question2>"},
            {"role": "assistant",  "content": "0.99"},
            {"role": "user",  "content": "<question1>明年棒球赛的冠军你猜会是谁?</question1><question2>小明联系地址在哪?</question2>"},
            {"role": "assistant",  "content": "0"},
            {"role": "user",  "content": prompt_text},
    ], temperature=0.5)
    return res.replace("\n", "").replace(" ", "")

# 测试
test_arr_getAIQsIS = [
    {"question1": "对公司有什么要求吗?","question2":"京昆石太高速2024年供电(外电)线路及变压器日常维护采购项目的联系地址在哪?"},
    {"question1": "对公司有什么要求吗?","question2":"京昆石太高速2024年供电(外电)线路及变压器日常维护采购项目的比选对公司有什么要求?"},
    {"question1": "小明叫什么名字?","question2":"微订科技的员工小明叫什么名字?"},
    {"question1": "他说昨天是周一吗?","question2":"海伦问昨天是周一吗?"},
    {"question1": "英子住在哪里?","question2":"海伦住在哪里?"},
]

for item in test_arr_getAIQsIS:
    res2 = getAIQsIS(item["question1"], item["question2"].replace("\n", ""))
    print(f"=== {item} -> {res2}")


image.png

十四、根据对话让模型推理出用户问题相对的目标(一般是名词)

这个判断会比较复杂,因为对话中可能涉及多个目标名词,需要明确让 LLM 提取最近的目标。所以会写比较多的 prompt 才行。而且拿到的结果不一定会准确,所以需要用到上面写的打分函数getAIQsIS来打一分,分数过低就重新推理一遍。


def random_between_03_and_08():
    """
    生成介于 0.3 和 0.8 之间的随机浮点数,保留一位小数精度
    需要调整,不要随机,按循序走一遍就行...
    """
    random_number = random.uniform(0.3, 0.8)
    rounded_number = round(random_number, 1)
    return rounded_number
 

# @title 根据对话让模型推理出用户问题相对的目标(一般是主语/名词)
def getAISubject(question, context, max_repeat = 10): 
    _max_repeat = max_repeat
    # 具体推理逻辑
    def doFn(temperature = 0.6):
        template = """
        记住这段对话,我会问你一些问题。 {context}
        """

        prompt = PromptTemplate(template=template, input_variables=["context"])
        prompt_text = prompt.format(context=context)
        print("主语推理 prompt_text:", prompt_text)
        # prompt 设置 | 多轮对话
        res = openchatGen([
            {"role": "user",  "content": "根据对话内容,如果用户最后的句子缺少目标名称,则需要添加它。目标可以是一个公司,一个人,等等。如果你不知道目标是什么,直接回复\"用户\"问题的内容就行,不要回复任何与用户的句子不相关的东西,不能更改用户问题的原本意思。"},
            {"role": "assistant",  "content": "好的。"},

            {"role": "user",  "content": "记住这段对话,我会问你一些问题。\n 用户: 变压器日常维护采购项目相关的竞标有吗? \n助理: 是的,有关于变压器日常维护采购项目的竞标信息。您之前提供的信息中提到了一项名为“京昆石太高速2024年供电(外电)线路及变压器日常维护采购项目”的竞标项目。 \n用户: 联系人是谁? \n "},
            {"role": "assistant",  "content": "好的,我记住了。"},
            {"role": "user",  "content": "将内容中的目标名称补充到 \"用户\" 最后提问的句子中给我。"},
            {"role": "assistant",  "content": "“京昆石太高速2024年供电(外电)线路及变压器日常维护采购项目”的竞标项目联系人是谁?"},

            {"role": "user",  "content": "记住这段对话,我会问你一些问题。\n 用户: 变压探伤仪配件采购相关的比选信息有吗? \n助理: 1. 项目名称:石家庄市轨道交通集团有限责任公司运营分公司2023年度探伤仪配件采购项目比选公告。 \n1.1 项目编号:SJZXJT-HWBX-202001 \n1.2 服务内容:探伤仪配件采购项目, \n用户: 联系人是谁? \n "},
            {"role": "assistant",  "content": "好的,我记住了。"},
            {"role": "user",  "content": "将内容中的目标名称补充到 \"用户\" 最后提问的句子中给我。"},
            {"role": "assistant",  "content": "石家庄市轨道交通集团有限责任公司运营分公司2023年度探伤仪配件采购项目比选”的竞标项目联系人是谁?"},

            {"role": "user",  "content": "记住这段对话,我会问你一些问题。\n 用户: 今年小红怎么样?\n助理: 小红非常的好。\n 用户: 今年小红打电话给小米了吗?\n助理: 是的已经打了。 \n用户: 小明吃饭了吗?\n "},
            {"role": "assistant",  "content": "好的,我记住了。"},
            {"role": "user",  "content": "将内容中的目标名称补充到 \"用户\" 最后提问的句子中给我。"},
            {"role": "assistant",  "content": "小明吃饭了吗?"},

            {"role": "user",  "content": "记住这段对话,我会问你一些问题。\n 用户: 联系电话是18216811014的比选项目名称叫什么?\n助理: 没找到呢。\n用户: 那这个联系电话是谁的?\n "},
            {"role": "assistant",  "content": "好的,我记住了。"},
            {"role": "user",  "content": "将内容中的目标名称补充到 \"用户\" 最后提问的句子中给我。"},
            {"role": "assistant",  "content": "18216811014这个联系电话是谁的?"},

            {"role": "user",  "content": "记住这段对话,我会问你一些问题。\n 用户: 京昆石太高速2024年供电(外电)线路及变压器日常维护采购项目比选的联系人是谁? \n助理: hi \n用户: 联系人是谁 \n助理: hi \n用户: 内容概括下 \n "},
            {"role": "assistant",  "content": "好的,我记住了。"},
            {"role": "user",  "content": "将内容中的目标名称补充到 \"用户\" 最后提问的句子中给我。"},
            {"role": "assistant",  "content": "京昆石太高速2024年供电(外电)线路及变压器日常维护采购项目比选的内容概括下"},


            {"role": "user",  "content": "记住这段对话,我会问你一些问题。\n 用户: 2024年安全设备规则库升级采购项目比选有吗?\n助理: “石家庄市京昆石太高速公路管理服务有限公司2024年安全设备规则库升级采购项目比选\" 为你找到了这个信息。\n用户: 属于什么行业的?\n助理: 铁路运输业。 \n用户: 比选什么时候开始? \n "},
            {"role": "assistant",  "content": "好的,我记住了。"},
            {"role": "user",  "content": "将内容中的目标名称补充到 \"用户\" 最后提问的句子中给我。"},
            {"role": "assistant",  "content": "“石家庄市京昆石太高速公路管理服务有限公司2024年安全设备规则库升级采购项目比选\"什么时候开始开始?"},

            {"role": "user",  "content": "记住这段对话,我会问你一些问题。\n 用户: 京昆石太高速2024年供电(外电)线路及变压器日常维护采购项目比选的联系人是谁? \n助理: 根据提供的文本内容,比选人名称为:石家庄市京昆石太高速公路管理服务有限公司。联系人:杨工。电话:0311-85869915。 \n用户: 代理机构的联系方式呢\n "},
            {"role": "assistant",  "content": "好的,我记住了。"},
            {"role": "user",  "content": "将内容中的目标名称补充到 \"用户\" 最后提问的句子中给我。"},
            {"role": "assistant",  "content": "京昆石太高速2024年供电(外电)线路及变压器日常维护采购项目的代理机构的联系方式呢"},

            {"role": "user",  "content": prompt_text},
            {"role": "assistant",  "content": "好的,我记住了。"},
            {"role": "user",  "content": "将内容中的目标名称补充到 \"用户\" 最后提问的句子中给我。"},
        ], temperature = temperature)
        return res

    res = doFn()
    # 正确性判断
    res2 = getAIQsIS(question, res)
    while float(res2) < 0.3 and _max_repeat > 0:
        temperature = random_between_03_and_08()
        print("\n\n",question, " -> ", res)
        print("得分过低,需要重新推理。当前得分:", res2)
        print("下一次推理温度:", temperature)
        res = doFn(temperature)
        res2 = getAIQsIS(question, res)
        _max_repeat -= 1

    return res
    
# 测试
test_arr_getAISubject = [ 
    {
        "question": "这个项目的比选范围说一下。",
        "context":  """
            用户: 京昆石太高速2024年供电(外电)线路及变压器日常维护采购项目比选的联系人是谁?
            助理: 根据您提供的文本内容,比选人名称为:石家庄市京昆石太高速公路管理服务有限公司。联系人:杨工。电话:0311-85869915。比选代理机构名称:河北省成套招标有限公司。地址:河北省石家庄市工农路486号。联系人:孟凡真、尉思源。 电话:0311-83086950
            用户: 比选内容概括下
        """
    },
]

test_index = 1
for item in test_arr_getAISubject:
    question = item["question"]
    context = item["context"]
    res = getAISubject(question, context)
    print(f"{test_index}. {question} -> {res}")
    test_index+=1

image.png

十五、从上下文中推理出答案的方法封装

写完了上面的那些方法后就进入了正题了,把检索到的知识碎片和用户的问题全部给到 LLM。让其推理。为了后面的使用,这里先封装一个输入输出函数。

这里封装很有必要,因为一次对话如果打分过低可能会被调用多次推理。


def getAnswerByContext(context, question, query_len, history=[], temperature = 0.6):
    # template = """根据用户的问题,从知识库中检索出来了 {query_len} 条相关信息,下面是具体内容:\n{context} \n 请根据内容回答用户问题,务必告诉用户从知识库中检索出来了多少条相关信息。"""
    # template = """记住这段内容,我有些问题要问你,请根据这段内容对我的问题进行回答,下面是具体内容:\n\n\n检索到相关信息共 {query_len} 条。\n \n{context}"""
    template = """<text>从知识库中检索出来了 {query_len} 条相关信息,下面是具体内容:\n{context}</text>"""

    prompt = PromptTemplate(template=template, input_variables=["context", "query_len"])
    prompt_text = prompt.format(context=context, question = question, query_len = query_len)
 
    messages = [
            {"role": "user", "content": "我会把一段文本放到<text></text>标签中,你需要根据标签中的内容对用户提出的问题进行回答,所有的回答必须参照标签中的内容。"},
            {"role": "assistant",  "content": "好的。"},
            {"role": "user", "content": prompt_text},
            {"role": "assistant",  "content": "请提出您的问题吧,我会根据内容对您的问题进行回复。"},
        ] + history + [
            {"role": "user",  "content": question}
        ]
 
    res = openchatGen(messages, temperature=temperature) 
    return res

# 测试
test_arr4 = [
    {"question": "小明认识小红吗?","context":"小红是一名三年级的学生,每次考试都第一名,成绩非常的好。"},
    {"question": "小红几年级?","context":"小红是一名三年级的学生,每次考试都第一名,成绩非常的好。"}
]

for item in test_arr4:
    res2 = getAnswerByContext(context=item["context"], question=item["question"], query_len = 1)
    print(f"=== {item} -> {res2}")


image.png

十六、闭环推理

这是整个程序的最后一步了,只需要 推理->打分->输出 即可,

# @title 闭环(结合向量数据库 + AI 微调检索句 + + AI 完善主语) 
query_doc = ""

# 对话历史
chat_historys = ""
chat_historys_arr = []
chat_historys_ai_use = "\n"

# gr 自带的history暂时不用...
# is_repat 是否是重新回答
def main_bh(question, is_repat = False):
    global query_doc, chat_historys, chat_historys_ai_use, chat_historys_arr

    # max_repeat 最多尝试多少次推理
    _max_repeat = 5
    # print(question)

      # 特殊指令
    if question == "/clear":
        chat_historys = ""
        chat_historys_ai_use = ""
        chat_historys_arr = []
        print("清理会话完毕!")
        return "清理会话完毕!"

    print("\n\n\n\n**************************************") 
 
    _question = question
 
    def format_docs(docs):
        # 文学作品需要去除换行等符号会更准确
        # pt = "\n\n".join(doc.page_content for doc in docs).replace("\n", "").replace(" ", "")

        # 比选数据 
        pt = "\n\n".join(doc.page_content for doc in docs) 
        return pt

    real_question = ""
    # print("is_repat", is_repat)
    if is_repat != True:
        chat_historys_ai_use += f"用户: {_question} \n"

    # 让模型完整用户语义
    # if len(chat_historys_arr) > 0 and is_repat == False:
    if len(chat_historys_arr) > 0:
        real_question = getAISubject(_question, chat_historys_ai_use) or _question
        # print('目标推理内容:', chat_historys_ai_use)
        print('目标推理结果:', real_question)
    else:
        real_question = _question

    # 检索内容需要去重 
    # 用模型处理一遍语义再进行向量数据库搜索
    retrieved_docs = retriever.invoke(getAIQuestion(real_question))  
    contexts = retrieved_docs;
    contexts_unique_list = []
    for item in contexts:
        if item not in contexts_unique_list:
            contexts_unique_list.append(item)

    # 最多只要一条数据,但是总数可以告诉llm  ing... 
    cur_query_context = format_docs(contexts_unique_list)
    query_doc = cur_query_context

    print("\n=================知识库=======================")
    print("检索到数量:", len(contexts_unique_list))
    for item in contexts_unique_list:
        print(item)
    print("========================================");

    temperature =  random_between_03_and_08() if is_repat == True else 0.5
    q_res = getAnswerByContext(
        context=query_doc,
        question=real_question,
        query_len = len(contexts_unique_list),
        history = chat_historys_arr,
        # is_repat 时需要随机取值
        temperature =temperature
    )

    # 删除换行 
    q_res_f = q_res.replace('\n', '。 ').replace('\r', '。 ')
    # 用模型推理下回答是否合理,不合理就重新执行本函数
    q_res_score = getAIQAIS(real_question, q_res_f) or "1.0"
    float_number = float(q_res_score)
    print("回答得分:", q_res_score)

    if float_number < 0.2:
        # 回答不合理,需要重新推理一次
        print(f"回答内容:{q_res_f}")
        print("回答不合理,需要重新推理一次")
        return main_bh(question, True) 
        
    chat_historys_arr.append({ "role":"user", "content":real_question })
    chat_historys_arr.append({ "role":"assistant", "content":q_res_f })  
    chat_historys_ai_use += f"助理: {q_res_f} \n"

    print("\n================结果========================")

    print("温度:", temperature)
    print(f"用户输入:{question}") 
    print(f"主语增加:{real_question}")
    print("回答->:", q_res) 
    print("========================================");

    return q_res 

def serverChat(msg, history):
    return main_bh(msg)
gr.ChatInterface(
    serverChat,
    retry_btn=None,
    undo_btn=None,
    clear_btn=None,
    description="胡言乱语时使用 /clear 指令清除会话"
).launch(share=True, debug = True) 

十七、最后效果

企业微信截图_17061728791984.png

企业微信截图_1706172896179.png

企业微信截图_17059888844411.png

企业微信截图_17059889028502.png

END

如果微调打分模型效果一定会更好。

如果每个步骤都使用不同的模型数一数要用多少个模型?

如何学习大模型

下面这些都是我当初辛苦整理和花钱购买的资料,现在我已将重要的AI大模型资料包括市面上AI大模型各大白皮书、AGI大模型系统学习路线、AI大模型视频教程、实战学习,等录播视频免费分享出来,需要的小伙伴可以扫取。

现在社会上大模型越来越普及了,已经有很多人都想往这里面扎,但是却找不到适合的方法去学习。

作为一名资深码农,初入大模型时也吃了很多亏,踩了无数坑。现在我想把我的经验和知识分享给你们,帮助你们学习AI大模型,能够解决你们学习中的困难。

一、AGI大模型系统学习路线

很多人学习大模型的时候没有方向,东学一点西学一点,像只无头苍蝇乱撞,我下面分享的这个学习路线希望能够帮助到你们学习AI大模型。

在这里插入图片描述

二、AI大模型视频教程

在这里插入图片描述

三、AI大模型各大学习书籍!

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

四、AI大模型各大场景实战案例

在这里插入图片描述

五、AI大模型面试题库

在这里插入图片描述

五、结束语

学习AI大模型是当前科技发展的趋势,它不仅能够为我们提供更多的机会和挑战,还能够让我们更好地理解和应用人工智能技术。通过学习AI大模型,我们可以深入了解深度学习、神经网络等核心概念,并将其应用于自然语言处理、计算机视觉、语音识别等领域。同时,掌握AI大模型还能够为我们的职业发展增添竞争力,成为未来技术领域的领导者。

再者,学习AI大模型也能为我们自己创造更多的价值,提供更多的岗位以及副业创收,让自己的生活更上一层楼。

因此,学习AI大模型是一项有前景且值得投入的时间和精力的重要选择。

LangChain(二)——构建多轮对话 因此,不同线程间的对话是隔开的,同一线程的对话是能被记录的,因为上面设置状态流图的内存检查点是记忆函数。是一种与对话流和任务流设计相关的框架或工具,它被设计为一种能够管理和处理复杂任务流(Task Flow)和状态流(State Flow)的工具,通常与语言模型(如 GPT 系列)结合使用,用于构建动态多轮对话系统或复杂的流程自动化任务。来构建多轮对话时,每个对话轮次是一个节点(Node),代表需要完成的任务(例如调用大模型或调用工具链),节点可以是同步或异步的函数,任务的完成可能依赖于上一个节点的输出。 阅读详情

相关推荐

大模型应用开发实战:从RAG到Agent,7天掌握AI应用构建全流程

大语言模型(LLM)作为当前人工智能的核心技术,正从通用对话向解决特定领域问题演进。其核心原理在于通过检索增强生成(RAG)和智能体(Agent)两大范式,为模型赋予实时知识获取与自主行动能力。RAG通过“先检索,后生成”的机制,将外部知识库与模型生成相结合,有效解决了知识滞后与幻觉问题,是构建企业级知识问答系统的关键技术。Agent则通过“思考-行动-观察”的循环,使模型能够调用外部工具,完成复杂任务序列,实现了从“思考者”到“行动者”的跨越。这些技术的工程价值在于,它们能将前沿的AI能力低成本、高效率地

weixin_30819085的博客 357

Langchain使用介绍之 - 基于向量存储进行检索

通过实际代码例子介绍如何将文本的向量进行存储,然后存储的向量检索答案

qiaotl的博客 8236

langchain 模型加载HuggingFaceEmbeddings、文本切割RecursiveCharacterTextSplitter与向量数据库使用FAISS

参考: https://github.com/TommyTang930/LangChain_LLM_ChatBot https://python.langchain.com/docs/integrations/vectorstores/faiss这里对着类进行了改写,对中文切分更友好 用于后续输入的就是chunks,是一个列表对于HuggingFace上的模型可以加载用作文本向量模型;这里加载的下载好的离线模型text2vec-base-chinese 3、向量数据库使用FAISS embedding就是上

weixin_42357472的博客 4408

【可能是全网最丝滑的LangChain教程】十五、LangChain进阶之Embedding Models

Embeddings 类为各种文本嵌入模型提供商提供了一个统一的接口,简化了模型的使用。 文本嵌入模型将文本转换为向量形式,便于在向量空间中进行操作,如语义搜索和相似度计算。

Jeffray1991的博客 4489

个人整理的数据集(手写中文数据、发票数据、快递单数据、车牌数据)

本人在工作生活中收集了各个方面比较多的真实的数据集如下: 一、手写中文数据集 1、档案类数据: 此数据集为手写档案数据,数量较大,大约128G,图像均未标注。 ex: 2、手写作文数据: 此数据集为手写作文数据,是大约800M左右,图像按行提供位置和内容标注,十分珍贵。 ex: 二、发票数据集: 1、增值税发票 此数据集包含了大量真实的增值税发票数据,大约9G,标注了发票位置数据,未提供详细标注。 ex: 2、购车发票 此数据集未提供标注。

weixin_43143224的博客 5883

MultiOTP Credential Provider避坑指南:从安装到RDP双因素认证的全流程解析

本文详细解析了MultiOTP Credential Provider从安装到实现RDP双因素认证(MFA)的全流程,重点分享了Docker部署、Active Directory集成及网络级认证(NLA)兼容性等环节的实战避坑经验,旨在帮助运维人员高效、稳定地部署离线双因素认证方案,提升Windows远程桌面安全性。

weixin_29255731的博客 647

提示词工程:从基础概念到RAG实战的工程化方法

你是不是也遇到过这种情况:花了几小时精心设计了一个问题,扔给 ChatGPT 或 Claude,结果得到的回答要么是“正确的废话”,要么干脆跑偏,完全不是你想要的。你开始怀疑,到底是模型不行,还是自己不会提问? 这背后的问题,恰恰是当前 AI 大模型应用中最核心、也最容易被忽视的一环: 提示词工程(Prompt Engineering) 。很多人以为它只是“把话说清楚”,但实际上,它是一门融合了心理学、语言学、软件工程和特定领域知识的系统性技术。一个优秀的提示词,能让一个普通模型发挥出专家级水平;而一个糟糕

cigang4063的博客 476

ONFI5.0命令字实战指南:从基础操作到高级应用

本文深入解析ONFI5.0协议的核心——命令字,提供从基础操作到高级应用的实战指南。详细拆解了NAND闪存的复位、读状态、数据读取(00-30)、页编程(80-10)和块擦除(60-D0)等关键命令周期,并探讨了多平面操作与缓存操作等高级性能优化技巧,帮助开发者高效、稳定地与NAND芯片进行底层交互。

vscode5coder的博客 463

从豆包AI标注看智能体开发:自托管RAG架构实战指南

大语言模型(LLM)作为AI应用的核心引擎,通过其强大的自然语言理解和生成能力,正在重塑人机交互方式。其技术原理基于Transformer架构,通过海量数据预训练和指令微调,实现了通用任务处理能力。在工程实践中,检索增强生成(RAG)技术通过结合外部知识库,有效解决了模型幻觉和知识更新滞后问题,显著提升了专业领域问答的准确性和时效性。这种架构模式在客服、教育、企业知识管理等场景中展现出巨大价值。本文以豆包智能体的AI生成内容标注现象为切入点,深入探讨如何利用LangChain框架和开源工具链,构建自主可控的

weixin_30652491的博客 365

复现论文《基于Retinex理论和深度学习的低照度图像增强算法研究》

本研究提出两种基于Retinex理论和深度学习的低照度图像增强算法。第一种算法在HSV色彩空间中进行处理,采用Res2Block和CBAM-Res2block模块增强多尺度特征表示;第二种算法使用多尺度残差U型网络结构。复现代码展示了Res2Block、CBAM注意力机制等核心模块的实现,包括多尺度特征提取、通道和空间注意力机制。实验结果表明,所提算法能有效解决低照度图像存在的亮度低、对比度不足、颜色失真和细节丢失等问题,显著提升图像质量。

max500600的博客 391

ardupilot BMI088加速度陀螺仪学习

本节主要记录ardupilot 中BMI088传感器的学习过程,欢迎批评指正。BMI088是一款高性能6轴惯性传感器,由16位数字三轴±24g加速度计和16位数字三轴±2000°/ s陀螺仪组成。 BMI088允许高精度测量方向和沿三个正交轴的运动检测。BMI088具有高振动鲁棒性和3 x 4.5 x0.95mm³的小尺寸,是用于无人机和机器人应用等恶劣环境的高性能IMU中的独特产品。 BMI088专门设计用于有效抑制由于PCB上的共振或整个系统的结构而可能发生的振动。 除了高振动稳定性外,BMI088的出

陌城烟雨 2057

LangChain上使用huggingface的embedding模型(如jina-embeddings-v3)

embedding将文本映射到稠密的向量空间中,方便存储和查询。这里结合自己的应用场景,选择1b以下的embedding模型,综合考量下选择arkohut/jina-embeddings-v3下载使用模型卡片提供的命令,用cmd下载(强烈建议使用SSH命令下载!!!!用http容易报错)需要使用魔法上网才能下载。如果超时的话,也可以选择手动下载。注意下载后的文件名应该和网站上提供的一样。

weixin_44737922的博客 2248

动态视频目标追踪系统:基于YOLOv11+DeepSORT的从入门到实战全流程指南

仅保留车辆类别(假设车辆类别ID为2)if det.class_index == 2: # 车辆类别ID通过本指南,你已完成从环境搭建数据准备模型训练到追踪系统与UI界面的全流程,搭建了一套完整的动态视频目标追踪系统。该系统在安防监控、交通管理等场景中具有实用价值,可实现目标的实时稳定追踪。未来,你可尝试结合多模态特征(如目标外观+运动特征)提升追踪鲁棒性,或探索轻量化模型部署(如TensorRT加速),让系统在边缘设备上也能高效运行。

LXY_LOVE36的博客 142

LangChain系列使用指南:组件介绍_数据处理_文本嵌入Embeddings

LangChain 中的基本 Embeddings 类提供了两种方法:一个用于嵌入文档,另一个用于嵌入查询。之所以将它们作为两个单独的方法,是因为一些嵌入提供商对文档(用于搜索)和查询(搜索查询本身)有不同的嵌入方法。这很有用,因为这意味着我们可以在向量空间中思考文本,并做一些类似语义搜索的操作,比如在向量空间中寻找最相似的文本片段。可以实现嵌入的缓存。缓存支持的嵌入器是一个包装器,用于在键值存储中缓存嵌入。首先,让我们看一个示例,该示例使用本地文件系统存储嵌入,并使用 FAISS 向量存储进行检索。

数智笔记 2885

gb28181之rtp负载之h264

我们知道国标中支持的媒体流格式不止一种,其中最常见的就数PS和h264(ES流中的其中一种)了,PS流我们之前的博文中已经分享过了,本篇博文我们来一起聊聊国标中媒体流的负载为h264的细节。 我们知道h264为了方便网络传输,把原始数据分装成了多个NALU,而NALU包大小是不固定的,因此有时候一个rtp包中可以负载多个NALU,有时候一个rtp包中只负载一个NALU,有时候多个rtp包中包含的...

2093

YOLO模型在STM32微控制器上的部署:1.98M参数如何塞进嵌入式设备?

<think>我们根据内容生成不超过150字的摘要。内容主要是关于YOLO模型在STM32微控制器上的部署,包括STM32N6 NPU、模型量化、工具链、开源方案和架构设计。摘要需要简洁概括主要点。 字数限制:≤150字。需要包含关键信息:STM32N6运行YOLO,困难,方案(NPU、INT8量化、工具链),性能(34 FPS 9.4mJ)。结尾可能提到开源和生态。 写中文摘要。注意不超过150字。</think>本文探讨YOLO模型在STM32微控制器上的部署。集成NPU的STM32N6搭配轻量化YOL

2601_95807009的博客 258

社区供稿 | 中文 LangChain 项目的实现开源工作

Chinese-LangChain 是 yanqiangmiffy 同学的开源项目https://hf.co/spaces/ChallengeHub/Chinese-LangChainhttps://github.com/yanqiangmiffy/Chinese-LangChain中文 langchain 项目,基于 ChatGLM-6b + langchain 实现本地化知识库检索与智能答案生...

Hugging Face 5192

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

LangChain 27 AI Agents角色扮演多轮对话解决问题CAMEL

对话和基于聊天的语言模型的快速发展已经取得了在复杂任务解决方面的显著进展。然而,它们的成功在很大程度上依赖于人类输入来引导对话,这可能具有挑战性且耗时。本文探讨了构建可扩展技术以促进沟通代理之间的自主合作,并洞察其“认知”过程的潜力。为了解决实现自主合作的挑战,我们提出了一个名为角色扮演的新型沟通代理框架。我们的方法涉及使用启发式提示来引导聊天代理完成任务,同时保持与人类意图的一致性。我们展示了角色扮演如何用于生成对话数据,以研究聊天代理的行为和能力,为研究对话语言模型提供了宝贵的资源。

AI架构师易筋 4139

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

LangChain手记 Memory

使用open ai的API调用GPT都是单次调用,所以模型并不记得之前的对话,多轮对话的实现其实是将前面轮次的对话过程保留,在下次对话时作为输入的message数组的一部分,再将新一轮对话的提问也放入message数组,再发起一次API调用,即构手动建对话流(以上笔者注)。方法构建对话历史(笔者注:此时对话历史中AI的回答是人为指定的,不是真实的GPT回复,这里是为了演示,实际使用时不推荐这么做,GPT的真实回复可能和指定的不同,并没有完全使用GPT)。内存储了所有的对话历史,不含输入提示词的其他部分。

Steve Wang's blog 4459

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

基于本地知识库的问答机器人langchain-ChatGLM

langchain-ChatGLM是一个基于本地知识的问答机器人,使用者可以自由配置本地知识,用户问题的答案也是基于本地知识生成的。GitHub - imClumsyPanda/langchain-ChatGLM: langchain-ChatGLM, local knowledge based ChatGLM with langchain | 基于本地知识的 ChatGLM 问答。

张伟的专栏 6994
上一篇: 使用在本地计算机上运行的 LLM 以及 Ollama 和 Langchain 构建 RAG 应用程序
下一篇: 大模型书籍推荐:Transformer自然语言处理: 构建语言应用,附409页pdf免费下载
少喝冰美式
博客等级 码龄3年 6847粉丝 517原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值