首页 > 其他分享 >Langchain-Chatchat项目:2.1-通过GPT2模型来检索NebulaGraph

Langchain-Chatchat项目:2.1-通过GPT2模型来检索NebulaGraph

时间:2023-10-07 23:45:30浏览次数:50  
标签:return name GPT2 Langchain Chatchat input import NebulaGraph

  在官方例子中给出了通过chain = NebulaGraphQAChain.from_llm(ChatOpenAI(temperature=0), graph=graph, verbose=True)来检索NebulaGraph图数据库。本文介绍了通过GPT2替换ChatOpenAI的思路和实现,暂时不考虑效果。之所以没用ChatGLM2是因为加载模型太慢,调试不方便,不过将GPT2替换为ChatGLM2也很方便。

一.通过ChatOpenAI来检索NebulaGraph
1.NebulaGraph_OpenAI.py代码实现
  如果没有ChatGPT的key和proxy是没法运行的,如下所示:

"""
langchain连接NebulaGraph的例子
"""
from langchain.chat_models import ChatOpenAI
from langchain.chains import NebulaGraphQAChain
from langchain.graphs import NebulaGraph

graph = NebulaGraph(
    space="basketballplayer",
    username="root",
    password="nebula",
    address="172.21.31.166",
    port=9669,
    session_pool_size=30,  # 设置连接池大小
)
print(graph.get_schema)

chain = NebulaGraphQAChain.from_llm(  # 从语言模型创建问答链
    ChatOpenAI(temperature=0), graph=graph, verbose=True
)
chain.run("Who played in The Godfather II?")

2.NebulaGraphQAChain默认prompt
  基本思路是介绍、举例、图Schema和限制,如下所示:

> Entering new NebulaGraphQAChain chain...
Generated nGQL:
Task:Generate NebulaGraph Cypher statement to query a graph database.

Instructions:

First, generate cypher then convert it to NebulaGraph Cypher dialect(rather than standard):
1. it requires explicit label specification only when referring to node properties: v.`Foo`.name
2. note explicit label specification is not needed for edge properties, so it's e.name instead of e.`Bar`.name
3. it uses double equals sign for comparison: `==` rather than `=`
For instance:
diff
< MATCH (p:person)-[e:directed]->(m:movie) WHERE m.name = 'The Godfather II'
< RETURN p.name, e.year, m.name;
---
> MATCH (p:`person`)-[e:directed]->(m:`movie`) WHERE m.`movie`.`name` == 'The Godfather II'
> RETURN p.`person`.`name`, e.year, m.`movie`.`name`;

Use only the provided relationship types and properties in the schema.
Do not use any other relationship types or properties that are not provided.
Schema:
Node properties: [{'tag': 'player', 'properties': [('name','string'), ('age', 'int64')]}, {'tag': 'team', 'properties': [('name','string')]}]
Edge properties: [{'edge': 'follow', 'properties': [('degree', 'int64')]}, {'edge':'serve', 'properties': [('start_year', 'int64'), ('end_year', 'int64')]}]
Relationships: ['(:player)-[:follow]->(:player)', '(:player)-[:serve]->(:team)']

Note: Do not include any explanations or apologies in your responses.
Do not respond to any questions that might ask anything else than for you to construct a Cypher statement.
Do not include any text except the generated Cypher statement.

The question is:
player100'age is what?

Full Context:
{}

二.通过GPT2来检索NebulaGraph
1.NebulaGraph_GPT2.py代码实现
  使用自定义的GPT2()替换ChatOpenAI(temperature=0)即可,如下所示:

"""
langchain连接NebulaGraph的例子
"""
from langchain.chains import NebulaGraphQAChain
from langchain.graphs import NebulaGraph
from examples.GPT2 import GPT2


graph = NebulaGraph(  # 连接NebulaGraph
    space="basketballplayer",
    username="root",
    password="nebula",
    address="172.24.211.214",
    port=9669,
    session_pool_size=30,  # 设置连接池大小
)
print(graph.get_schema)  # 获取图的schema

chain = NebulaGraphQAChain.from_llm(  # 从语言模型创建问答链
    GPT2(), graph=graph, verbose=True
)
chain.run("player100'name is what?")  # 运行问答链
chain.run("player100'age is what?")  # 运行问答链

2.GPT2.py代码实现
  主要是继承LLM类,并且实现def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:函数,如下所示:

import time
import logging
import requests
from typing import Optional, List, Dict, Mapping, Any

import langchain
from langchain.llms.base import LLM
from langchain.cache import InMemoryCache

logging.basicConfig(level=logging.INFO)
# 启动llm的缓存,如果同一个问题被第二次提问,模型可以快速给出答案,而不用再次调用模型,节省时间
langchain.llm_cache = InMemoryCache()


class GPT2(LLM):
    # 模型服务url
    url = "http://127.0.0.1:8595/chat"

    @property  # 这个装饰器的作用是将一个方法变成一个属性来使用
    def _llm_type(self) -> str:
        return "gpt2"

    def _construct_query(self, prompt: str) -> Dict:
        """
        构造请求体
        """
        query = {
            "human_input": prompt
        }
        return query

    @classmethod  # 这个装饰器的作用是将一个方法变成一个类方法来使用
    def _post(cls, url: str, query: Dict) -> Any:
        """
        POST请求
        """
        _headers = {"Content_Type": "application/json"}
        with requests.session() as sess:  # 这个with语句的作用是在这个语句块中创建的对象,会在执行完语句块后自动销毁
            resp = sess.post(url, json=query, headers=_headers, timeout=60)
        return resp

    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
        """
        注释:这个方法是用来调用模型的,这个方法的参数是prompt和stop,prompt是用户输入的内容,stop是用户输入的结束标志
        """
        query = self._construct_query(prompt=prompt)  # 构造请求体
        resp = self._post(url=self.url, query=query)  # post请求

        if resp.status_code == 200:  # 判断请求是否成功
            resp_json = resp.json()  # 获取返回结果
            predictions = resp_json['response']  # 获取返回结果中的response字段
            return predictions  # 返回模型结果
        else:
            return "请求模型"

    @property  # 这个装饰器的作用是将一个方法变成一个属性来使用
    def _identifying_params(self) -> Mapping[str, Any]:
        """
        这个方法的作用是获取识别参数
        """
        _param_dict = {
            "url": self.url
        }
        return _param_dict


if __name__ == "__main__":
    llm = GPT2()  # 实例化GPT2类
    while True:  # 这个while循环的作用是让用户可以一直输入
        human_input = input("Human: ")  # 获取用户输入
        begin_time = time.time() * 1000  # 获取当前时间

        response = llm(human_input, stop=["you"])  # 调用模型
        end_time = time.time() * 1000  # 获取当前时间
        used_time = round(end_time - begin_time, 3)  # 计算模型调用时间
        logging.info(f"GPT2 process time: {used_time}ms")  # 打印模型调用时间

        print(f"GPT2: {response}")  # 打印模型返回结果

3.GPT2_Flask.py代码实现
  主要是通过Flask将GPT2进行API封装,如下所示:

import os
import json
import torch
from flask import Flask
from flask import request
from transformers import GPT2LMHeadModel, GPT2Tokenizer

os.environ["CUDA_VISIBLE_DEVICES"] = "0"  # 指定GPU,0表示使用第一个GPU

pretrained_model_name_or_path = "L:/20230713_HuggingFaceModel/gpt2"
tokenizer = GPT2Tokenizer.from_pretrained(pretrained_model_name_or_path, trust_remote_code=True)
model = GPT2LMHeadModel.from_pretrained(pretrained_model_name_or_path, trust_remote_code=True).half().cuda()
model.eval()

app = Flask(__name__)


@app.route("/", methods=["POST", "GET"])
def root():
    return "Welcome to gpt2 model"


@app.route("/chat", methods=["POST"])
def chat():
    data_seq = request.get_data()  # 获取请求数据
    data_dict = json.loads(data_seq)  # 将请求数据转换为字典
    human_input = data_dict["human_input"]  # 获取请求数据中的human_input字段

    # response, _ = model.chat(tokenizer, human_input, history=[])  # ChatGLM可使用这个方法

    # 将输入文本编码为令牌
    input_ids = tokenizer.encode(human_input, return_tensors="pt")
    input_ids = input_ids.cuda()
    # 进行模型推理
    with torch.no_grad():  # 这个with语句的作用是在这个语句块中创建的对象,会在执行完语句块后自动销毁
        output = model.generate(input_ids, max_length=50, num_return_sequences=1)  # 生成模型输出,max_length表示生成的最大长度,num_return_sequences表示生成的序列数
    output = output.cuda()
    # 将生成的令牌解码为字符串,skip_special_tokens=True表示跳过特殊字符,clean_up_tokenization_spaces=True表示清理分词空格
    response = tokenizer.decode(output[0], skip_special_tokens=True, clean_up_tokenization_spaces=True)

    result_dict = {  # 构造返回结果
        "response": response
    }
    result_seq = json.dumps(result_dict, ensure_ascii=False)  # 将返回结果转换为json字符串
    return result_seq  # 返回结果


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8595, debug=False)

  因为通用LLM通过prompt将text转换为nGQL并不专业,觉得以后的发展思路应该还是专用LLM作为agent来做这个事情。

参考文献:
[1]https://huggingface.co/gpt2
[2]使用LLMs模块接入自定义大模型:https://blog.csdn.net/zhaomengsen/article/details/130585397
[3]https://github.com/ai408/Langchain-Chatchat/blob/master/examples/NebulaGraph_GPT2.py
[4]https://github.com/ai408/Langchain-Chatchat/blob/master/examples/GPT2.py
[5]https://github.com/ai408/Langchain-Chatchat/blob/master/examples/GPT2_Flask.py

标签:return,name,GPT2,Langchain,Chatchat,input,import,NebulaGraph
From: https://www.cnblogs.com/shengshengwang/p/17747783.html

相关文章

  • Langchain-Chatchat项目:3-Langchain计算器工具Agent思路和实现
      本文主要讨论Langchain-Chatchat项目中自定义Agent问答的思路和实现。以"计算器工具"为例,简单理解就是通过LLM识别应该使用的工具类型,然后交给相应的工具(也是LLM模型)来解决问题。一个LLM模型可以充当不同的角色,要把结构化的Prompt模板写好,充分利用LLM的Zero/One/Few-Shot能力......
  • GPT之路(九) LangChain - Memory
          记忆封装-Memory(langchainmemory)         Memory:这里不是物理内存,从文本的角度,可以理解为“上文”、“历史记录”或者说“记忆力”的管理          ConversationBufferMemory可也用来保留会话信息 ......
  • 文章《Semantic Kernel -- LangChain 的替代品?》的错误和疑问 探讨
    微信公众号文章SemanticKernel——LangChain的替代品?[1],它使用的示例代码是Python,他却发了这么一个疑问:支持的语言对比(因为SemanticKernel是用C#开发的,所以它对C#比较支持)如上所示。不清楚SemanticKernel为什么要用C#来开发,C#相比Python和JavaScript来说使用......
  • LangChain大模型应用开发指南-传统编程范式思维的应用
    LangChain大模型应用开发指南-传统编程范式思维的应用上节课,我带领小伙伴们完成了baichuan2量化模型的OpenAI标准接口封装,并完成LangChain对大模型的调用与测试。没有看过的小伙伴可以点击链接查看:AI课程合集今天我们将正式开始LangChain大模型应用开发课程。组件总览上图......
  • LangChain大模型应用开发指南-AI大模型衍生的新能力
    LangChain大模型应用开发指南-AI大模型衍生的新能力上节课,我以传统应用编程设计模式和思维为入口和对比对象,介绍了LangcChain中的Chain、Agent、Callback三大核心概念,并整理了LangcChain为众多开发者内置的能力与工具。没有看过的小伙伴可以点击链接查看:大模型OpenAI标准接口封......
  • 本地部署 Langchain-Chatchat & ChatGLM
    一、模型&环境介绍1.ChatGLMgithub地址:https://github.com/THUDM模型地址:https://huggingface.co/THUDM2.m3e模型地址:https://huggingface.co/moka-ai/m3e-base/3.text2vec模型地址:https://huggingface.co/GanymedeNil/text2vec-large-chinese/4.Langchain-Cha......
  • LangChain使用fine-tuned GPT-3.5
    LangChain使用fine-tunedGPT-3.5参考:https://openai.com/blog/gpt-3-5-turbo-fine-tuning-and-api-updateshttps://platform.openai.com/docs/guides/fine-tuninghttps://qiita.com/MandoNarin/items/6fadb78f357c66e25502事前准备!pipinstallopenai!pipinstalltiktok......
  • LangChain开发环境准备-AI大模型私有部署的技术指南
    LangChain开发环境准备-AI大模型私有部署的技术指南今天开始小智将开启系列AI应用开发课程,主要基于LangChain框架基于实战项目手把手教大家如何将AI这一新时代的基础设施应用到自己开发应用中来。欢迎大家持续关注当下在AI应用开发领域,LangChain框架可以说是唯一选择。然而,上......
  • GPT之路(八) LangChain - Models入门
    环境:Python3.11.4,LangChain0.0.270,Jupyter Models模型简介官方地址:LangChian-ModelsLangchain所封装的模型分为两类:大语言模型(LLM)聊天模型(ChatModels)Langchain的支持众多模型供应商,包括OpenAI、ChatGLM、ModelScope、HuggingFace等。后面的示例我将以OpenA......
  • GPT之路(七) LangChain AI编成框架入门的第一个demo
    环境:Python3.11.4,LangChain0.0.2701.Langchain简介1.1 PythonLangchain官方文档大型语言模型(LLM)正在成为一种具有变革性的技术,使开发人员能够构建以前无法实现的应用程序。然而,仅仅依靠LLM还不足以创建一个真正强大的应用程序。它还需要其他计算资源或知识来源。Langch......