langchain加载本地中文模型的4种方法_langchain调用本地大模型

langchain如何接其他中文大模型

根据langchain接chatglm的demo参考，两种方法：

方法1：基于langchain要求的格式封装一个LLM

本地代码：/myCode/LLM/langchain/langchain_myWork/chatglm_llm.py
1

1.基于langchain要求的格式封装一个LLM
2.实例化这个LLM
3.这个LLM执行各种chain
参考：https://zhuanlan.zhihu.com/p/670837521

https://python.langchain.com.cn/docs/modules/model_io/models/llms/how_to/custom_llm 如何用lainchain调用自定义模型

https://www.yangyanxing.com/article/use-langchain-custom-stream.html 用langchian调用阿里云模型
https://www.tizi365.com/topic/2321.html langchain调用自定义模型
https://www.masenlin.com/archives/zi-ding-yi-llmlangchain-yu-wen-xin-yi-yan-ca-chu-huo-hua 与文心一言的结合使用
1
2
3
4
5
6
7
8
9
10

使用中文 参考：https://github.com/taishan1994/langchain-learning
1

方法2：先部署大模型，从部署的api作为模型入口

本地代码： myCode/LLM/langchain/langchain_myWork/baichuan_FastApideploy.py
1

参考：https://blog.csdn.net/qq_36187610/article/details/131900517
1.部署本地模型，暴露出接口api
2.重写call方法，其中request请求该api
1
2
3

方法3：使用huggfacepipline来调用本地模型

本地代码：myCode/LLM/langchain/langchain_myWork/mychain/HuggingFacePipelineTest.py
1

1.先定义模型，并用AutoModel导入

model_path = "/datadir/chatglm3-6b"
# load model from huggingface，load因果语言类大模型的时候就用这个函数 AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained(
        model_path,
        load_in_4bit=True,
        torch_dtype=torch.float16,
        device_map='auto'

1
2
3
4
5
6
7
8

2.构建transformer的pipline

from transformers import pipeline
  # 构建 transformer的pipline
    pipe = pipeline(
        "text-generation",  # 名称
        model=model,  # 模型
        torch_dtype=torch.bfloat16,  # 模型加载方式
        device_map='auto',
        max_new_tokens=512,  # 最大token
        do_sample=True,
        top_k=30,
        num_return_sequences=1,
        tokenizer=tokenizer,
        eos_token_id=tokenizer.eos_token_id
    )
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.基于huggfacepipline构建llm服务，并构建chain，实现各种应用

    llm = HuggingFacePipeline(pipeline=pipe, model_kwargs={'temperature': 0})
    system_prompt = "你是一个智能助手，对于用户提出的问题，你可以简洁又专业的给出回答。当用户对你打招呼，或者问你的身份问题，或者让你做自我介绍时，都要回答如下：我是来自xx的智能助手，我是由xx工程师开发的。"
    instruction = "回答如下问题:\n\n {text}"
    template = get_prompt(instruction, system_prompt)
    print(template)

    prompt = PromptTemplate(template=template, input_variables=["text"])
    llm_chain = LLMChain(prompt=prompt, llm=llm)

    text = "你是谁，你来自哪里。告诉我太阳为什么从东边升起！"
    output = llm_chain.run(text)
    parse_text(output)
1
2
3
4
5
6
7
8
9
10
11
12

方法4：直接调用官方大模型的api来封装LLM

参考 https://juejin.cn/post/7309549192774926363
1

方法2中自己部署模型api需要一直保持那个服务在线，有时候不方便长期开端口。可以直接调用官方大模型的api来作为LLM的服务入口。

方法5：使用fastchat来部署模型，可以提供与openai兼容的api，

部署方法

# 1.安装依赖环境
pip3 install fschat[model_worker,webui]  pydantic==1.10.13
pip3 install transformers accelerate sentencepiece

##2.启动 controller ： 注意：ai05上，使用ip 172,17.0.1 反正能执行成功，具体ai05的ip是多少，我不知
python3 -m fastchat.serve.controller --host 172.17.0.1 --port 21001   

##3 导入模型地址
 python3 -m fastchat.serve.model_worker --load-8bit --model-path /dataset_disk1/chatglm3-6b --controller-address http://172.17.0.1:21001 --worker-address http://172.17.0.1:8080 --host 0.0.0.0 --port 8080
 #4 启动服务
 python3 -m fastchat.serve.openai_api_server --controller-address http://172.17.0.1:21001 --host 0.0.0.0 --port 8000

1
2
3
4
5
6
7
8
9
10
11
12

代码中如下写传入请求并获得结果

 #5 代码中传入请求并获得结果
     def _ask_chatglm(self, prompt: str) -> str:
        headers = {
            "Content-Type": "application/json" }
        resp = requests.post(self.chatglm_api_url, headers = headers, json={
            "model": "chatglm3-6b",
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.7
        })
        # print ("result:",resp.json()['choices'])
        return resp.json()['choices'][0]['message']['content']
1
2
3
4
5
6
7
8
9
10
11

---

langchain-Tool的实现方法

tool集合包括了两层：

工具逻辑api层：定义了工具的具体功能，实现逻辑

Tool工具包括如下几部分：

名称：tool_name   tool必须有名字，并且唯一
描述：description agent会根据描述来选择工具
arg_schema:对输入参数做更多校验
1
2
3

Tool的定义方法：

方法一：基于Tool dataclass定义一个函数。这种情况适用于langchain中已经定义了的tool的使用

1. search = SerpAPIWrapper() 先封装一个接口

2. 定义tool，包含名称，描述
from langchain.agents.tools import Tool
tools = [
    Tool(
        name = "Search",
        func=search.run,
        description="useful for when you need to answer questions about current events"
    ),
    
1
2
3
4
5
6
7
8
9
10
11

方法二：基于BaseTool，实现tool。要包含tool的name，description，run逻辑的定义。

class CustomSearchTool(BaseTool):
    name = "custom_search"
    description = "useful for when you need to answer questions about current events"

    def _run(
        self, query: str, run_manager: Optional[CallbackManagerForToolRun] = None
    ) -> str:
        """Use the tool."""
        return search.run(query)
        
 tools = [CustomSearchTool(), CustomCalculatorTool()]
1
2
3
4
5
6
7
8
9
10
11

方法三：基于@Tool装饰器的方式定义工具

from langchain.tools import tool
#定义tool如下
@tool
def search(query: str) -> str:
    """Searches the API for the query."""
    return f"Results for query {query}"

#声明tool如下
Tool(name='search', description='search(query: str) 
1
2
3
4
5
6
7
8
9

参考 哔站解说 https://www.bilibili.com/video/BV1Di4y1879d/?spm_id_from=333.788.recommend_more_video.0&vd_source=c4e1d9d645f9a1554bc220274b5b24a8
1

agent调用该tool的方法

方法一：
    定义agent执行器
executor = load_agent_executor(model, tools, verbose=True)
   定义agent并执行
agent = PlanAndExecute(planner=planner, executor=executor, verbose=True)
agent.run("中国前2的特种磨具陶瓷企业，生产1000份磨具陶瓷需要多少钱?")

方法二：
   初始化agent
agent = initialize_agent(
    tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
   执行agent.run
agent.run(
    "Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?"
)

方法三：invoke的函数
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, memory=memory)
agent_executor.invoke({"input": "hi, i am bob"})['output']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

langchainj-agent的实现

是将LLM作为一个核心引擎，多次循环被调用，每次调用时候基于如下提示：

这里是一个问题: “{question}”
你可以使用这些工具: {tools_descriptions}。
首先，你需要进行‘思考: {your_thoughts}’，接下来你可以:
- 以正确的 JSON 格式发起工具调用，
- 或者，以‘最终答案:’为前缀来输出你的答案
1
2
3
4
5

等得到LM的输出后，解析LLM的输出：

• 如果输出中包含‘最终答案:’ 字符串，循环便结束，并输出该答案;

• 若不包含，则表示 LLM 进行了工具调用: 你需解析此输出以获得工具的名称及其参数，随后根据这些参数执行相应工具的调用。此工具调用的结果将被追加至提示信息中，然后你将带有这些新增信息的提示再次传递给 LLM，直至它获得足够的信息来给出问题的最终答案。

  

参考 agent详解：https://blog.csdn.net/weixin_45626120/article/details/132121731
1

Agent的输入有：

1. 可用的工具列表。

2. 用户输入。

3. intermediate_steps，表示之前执行完成的操作。

Agent的输出有：

AgentAction 和 AgentFinish

1. AgentAction：这是一个数据类，代表要执行的操作。它有两个属性：属性tool代表工具名称，属性tool_input表示工具的输入。

   代码如下：

    def plan(
               self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
       ) -> Union[AgentAction, AgentFinish]:
           # only for single tool
           tool_name = self.choose_tools(kwargs["input"])[0]
           return AgentAction(tool=tool_name, tool_input=kwargs["input"], log="") (返回要执行的动作，包括tool和tool的输入)
   1
   2
   3
   4
   5
   6

2. AgentFinish：这是一个数据类，表示Agent已经完成，应该返回给用户了，它有一个字典参数return_values。

   代码如下：

           if "Final Answer:" in llm_output:
               self.begin = True
               return AgentFinish(
                   return_values={"output": llm_output.split("Final Answer:", 1)[-1].strip()},
                   log=llm_output,
               )   （agent执行成功，返回最终结果）
           parts = llm_output.split("Action:")
           if len(parts) < 2:
               return AgentFinish(
                   return_values={"output": f"调用agent工具失败，该回答为大模型自身能力的回答:\n\n `{llm_output}`"},
                   log=llm_output,
               )  （agent调用失败，返回错误说明）
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12

Agent部分的逻辑实现：

1.把封装好的LLM集成进来作为控制核心

2.引入toolset

3.涉及引擎控制逻辑，基于intent_template,通过chooseTools来根据用户输入选择调用tool

Agent模式：

Langchain 设置了两种模式：一种Action Agents，就是下一步的动作由上一步的输出决定;另外一种Plan-and-execute agents，就是计划好所有的步骤，然后顺序执行; Action Agents 中类型有多种。

参考：讲解很详细的agent的用法  https://brightinventions.pl/blog/introducing-langchain-agents-tutorial-with-example/
1