langchain加载本地中文模型的4种方法

langchain如何接其他中文大模型

根据langchain接chatglm的demo参考，两种方法：
方法1：基于langchain要求的格式封装一个LLM

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

复制代码

1. 1.基于langchain要求的格式封装一个LLM
2. 2.实例化这个LLM
3. 3.这个LLM执行各种chain
4. 参考：https://zhuanlan.zhihu.com/p/670837521
6. https://python.langchain.com.cn/docs/modules/model_io/models/llms/how_to/custom_llm 如何用lainchain调用自定义模型
8. https://www.yangyanxing.com/article/use-langchain-custom-stream.html 用langchian调用阿里云模型
9. https://www.tizi365.com/topic/2321.html langchain调用自定义模型
10. https://www.masenlin.com/archives/zi-ding-yi-llmlangchain-yu-wen-xin-yi-yan-ca-chu-huo-hua 与文心一言的结合使用

复制代码

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

复制代码

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

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

复制代码

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

复制代码

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

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

复制代码

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

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

复制代码

2.构建transformer的pipline

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

复制代码

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

1.     llm = HuggingFacePipeline(pipeline=pipe, model_kwargs={'temperature': 0})
2.     system_prompt = "你是一个智能助手，对于用户提出的问题，你可以简洁又专业的给出回答。当用户对你打招呼，或者问你的身份问题，或者让你做自我介绍时，都要回答如下：我是来自xx的智能助手，我是由xx工程师开发的。"
3.     instruction = "回答如下问题:\n\n {text}"
4.     template = get_prompt(instruction, system_prompt)
5.     print(template)
7.     prompt = PromptTemplate(template=template, input_variables=["text"])
8.     llm_chain = LLMChain(prompt=prompt, llm=llm)
10.     text = "你是谁，你来自哪里。告诉我太阳为什么从东边升起！"
11.     output = llm_chain.run(text)
12.     parse_text(output)

复制代码

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

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

复制代码

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

部署方法

1. # 1.安装依赖环境
2. pip3 install fschat[model_worker,webui]  pydantic==1.10.13
3. pip3 install transformers accelerate sentencepiece
5. ##2.启动 controller ： 注意：ai05上，使用ip 172,17.0.1 反正能执行成功，具体ai05的ip是多少，我不知
6. python3 -m fastchat.serve.controller --host 172.17.0.1 --port 21001   
8. ##3 导入模型地址
9. 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
10. #4 启动服务
11. python3 -m fastchat.serve.openai_api_server --controller-address http://172.17.0.1:21001 --host 0.0.0.0 --port 8000

复制代码

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

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

复制代码

---

langchain-Tool的实现方法

tool集合包括了两层：
工具逻辑api层：定义了工具的具体功能，实现逻辑
Tool工具包括如下几部分：

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

复制代码

Tool的定义方法：

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

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

复制代码

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

1. class CustomSearchTool(BaseTool):
2.     name = "custom_search"
3.     description = "useful for when you need to answer questions about current events"
5.     def _run(
6.         self, query: str, run_manager: Optional[CallbackManagerForToolRun] = None
7.     ) -> str:
8.         """Use the tool."""
9.         return search.run(query)
10.         
11. tools = [CustomSearchTool(), CustomCalculatorTool()]

复制代码

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

1. from langchain.tools import tool
2. #定义tool如下
3. @tool
4. def search(query: str) -> str:
5.     """Searches the API for the query."""
6.     return f"Results for query {query}"
8. #声明tool如下
9. Tool(name='search', description='search(query: str)

复制代码

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

复制代码

agent调用该tool的方法

1. 方法一：
2.     定义agent执行器
3. executor = load_agent_executor(model, tools, verbose=True)
4.    定义agent并执行
5. agent = PlanAndExecute(planner=planner, executor=executor, verbose=True)
6. agent.run("中国前2的特种磨具陶瓷企业，生产1000份磨具陶瓷需要多少钱?")
8. 方法二：
9.    初始化agent
10. agent = initialize_agent(
11.     tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
12. )
13.    执行agent.run
14. agent.run(
15.     "Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?"
16. )
18. 方法三：invoke的函数
19. agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, memory=memory)
20. agent_executor.invoke({"input": "hi, i am bob"})['output']

复制代码

langchainj-agent的实现

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

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

复制代码

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

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

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

复制代码

Agent的输入有：

可用的工具列表。
用户输入。
intermediate_steps，表示之前执行完成的操作。

Agent的输出有：

AgentAction 和  AgentFinish

• AgentAction：这是一个数据类，代表要执行的操作。它有两个属性：属性tool代表工具名称，属性tool_input表示工具的输入。
  代码如下：
  1. def plan(
  2.             self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
  3.     ) -> Union[AgentAction, AgentFinish]:
  4.         # only for single tool
  5.         tool_name = self.choose_tools(kwargs["input"])[0]
  6.         return AgentAction(tool=tool_name, tool_input=kwargs["input"], log="") (返回要执行的动作，包括tool和tool的输入)

  复制代码
• AgentFinish：这是一个数据类，表示Agent已经完成，应该返回给用户了，它有一个字典参数return_values。
  代码如下：
  1.         if "Final Answer:" in llm_output:
  2.             self.begin = True
  3.             return AgentFinish(
  4.                 return_values={"output": llm_output.split("Final Answer:", 1)[-1].strip()},
  5.                 log=llm_output,
  6.             )   （agent执行成功，返回最终结果）
  7.         parts = llm_output.split("Action:")
  8.         if len(parts) < 2:
  9.             return AgentFinish(
  10.                 return_values={"output": f"调用agent工具失败，该回答为大模型自身能力的回答:\n\n `{llm_output}`"},
  11.                 log=llm_output,
  12.             )  （agent调用失败，返回错误说明）

  复制代码

Agent部分的逻辑实现：

1.把封装好的LLM集成进来作为控制核心
2.引入toolset
3.涉及引擎控制逻辑，基于intent_template,通过chooseTools来根据用户输入选择调用tool
Agent模式：

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

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

复制代码