Revert "Merge branch 'master' into 'master'"

This reverts merge request !2

finetune_demo/lora_inf.sh

-export HIP_VISIBLE_DEIVCES=7
-python inference_hf.py /path/to/checkpoint/ --prompt "类型#裙*版型#显瘦*材质#网纱*风格#性感*裙型#百褶*裙下摆#压褶*裙长#连衣裙*裙衣门襟#拉链*裙衣门襟#套头*裙款式#拼接*裙款式#拉链*裙款式#木耳边*裙款式#抽褶*裙款式#不规则"

finetune_demo/process.py

-import json
-from typing import Union
-from pathlib import Path
-
-
-def _resolve_path(path: Union[str, Path]) -> Path:
-    return Path(path).expanduser().resolve()
-
-
-def _mkdir(dir_name: Union[str, Path]):
-    dir_name = _resolve_path(dir_name)
-    if not dir_name.is_dir():
-        dir_name.mkdir(parents=True, exist_ok=False)
-
-
-def convert_adgen(data_dir: Union[str, Path], save_dir: Union[str, Path]):
-    def _convert(in_file: Path, out_file: Path):
-        _mkdir(out_file.parent)
-        with open(in_file, encoding='utf-8') as fin:
-            with open(out_file, 'wt', encoding='utf-8') as fout:
-                for line in fin:
-                    dct = json.loads(line)
-                    sample = {'conversations': [{'role': 'user', 'content': dct['content']},
-                                                {'role': 'assistant', 'content': dct['summary']}]}
-                    fout.write(json.dumps(sample, ensure_ascii=False) + '\n')
-
-    data_dir = _resolve_path(data_dir)
-    save_dir = _resolve_path(save_dir)
-
-    train_file = data_dir / 'train.json'
-    if train_file.is_file():
-        out_file = save_dir / train_file.relative_to(data_dir)
-        _convert(train_file, out_file)
-
-    dev_file = data_dir / 'dev.json'
-    if dev_file.is_file():
-        out_file = save_dir / dev_file.relative_to(data_dir)
-        _convert(dev_file, out_file)
-
-
-convert_adgen('data/AdvertiseGen', 'data/AdvertiseGen_fix')

finetune_demo/requirements.txt

-jieba>=0.42.1
-ruamel_yaml>=0.18.6
-rouge_chinese>=1.0.3
-jupyter>=1.0.0
-datasets>=2.18.0
-peft>=0.10.0
-#deepspeed==0.13.1
-mpi4py>=3.1.5

finetune_demo/sft.sh

-export HIP_VISIBLE_DEVICES=1,2,3,4
-export HSA_FORCE_FINE_GRAIN_PCIE=1
-
-torchrun --standalone --nnodes=1 --nproc_per_node=4  finetune_hf_sft.py  data/AdvertiseGen_fix  /path/to/chatglm3-6b  configs/sft.yaml

finetune_demo/sft_inf.sh

-export HIP_VISIBLE_DEIVCES=7
-python inference_hf.py /path/to/checkpoint/ --prompt "类型#裙*版型#显瘦*材质#网纱*风格#性感*裙型#百褶*裙下摆#压褶*裙长#连衣裙*裙衣门襟#拉链*裙衣门襟#套头*裙款式#拼接*裙款式#拉链*裙款式#木耳边*裙款式#抽褶*裙款式#不规则"

langchain_demo/ChatGLM3.py

-import ast
 import json
 from langchain.llms.base import LLM
 from transformers import AutoTokenizer, AutoModel, AutoConfig
 from typing import List, Optional
+from utils import tool_config_from_file
 
 
 class ChatGLM3(LLM):
     max_token: int = 8192
-    do_sample: bool = True
+    do_sample: bool = False
     temperature: float = 0.8
     top_p = 0.8
     tokenizer: object = None
     model: object = None
     history: List = []
+    tool_names: List = []
     has_search: bool = False
 
     def __init__(self):
@@ -32,50 +33,32 @@ class ChatGLM3(LLM):
             trust_remote_code=True
         )
         self.model = AutoModel.from_pretrained(
-            model_name_or_path, config=model_config, trust_remote_code=True, device_map="auto").eval()
+            model_name_or_path, config=model_config, trust_remote_code=True
+        ).half().cuda()
 
     def _tool_history(self, prompt: str):
         ans = []
-
         tool_prompts = prompt.split(
             "You have access to the following tools:\n\n")[1].split("\n\nUse a json blob")[0].split("\n")
-        tools_json = []
-
-        for tool_desc in tool_prompts:
-            name = tool_desc.split(":")[0]
-            description = tool_desc.split(", args:")[0].split(":")[1].strip()
-            parameters_str = tool_desc.split("args:")[1].strip()
-            parameters_dict = ast.literal_eval(parameters_str)
-            params_cleaned = {}
-            for param, details in parameters_dict.items():
-                params_cleaned[param] = {'description': details['description'], 'type': details['type']}
 
-            tools_json.append({
-                "name": name,
-                "description": description,
-                "parameters": params_cleaned
-            })
+        tool_names = [tool.split(":")[0] for tool in tool_prompts]
+        self.tool_names = tool_names
+        tools_json = []
+        for i, tool in enumerate(tool_names):
+            tool_config = tool_config_from_file(tool)
+            if tool_config:
+                tools_json.append(tool_config)
+            else:
+                ValueError(
+                    f"Tool {tool} config not found! It's description is {tool_prompts[i]}"
+                )
 
         ans.append({
             "role": "system",
             "content": "Answer the following questions as best as you can. You have access to the following tools:",
             "tools": tools_json
         })
-
-        dialog_parts = prompt.split("Human: ")
-        for part in dialog_parts[1:]:
-            if "\nAI: " in part:
-                user_input, ai_response = part.split("\nAI: ")
-                ai_response = ai_response.split("\n")[0]
-            else:
-                user_input = part
-                ai_response = None
-
-            ans.append({"role": "user", "content": user_input.strip()})
-            if ai_response:
-                ans.append({"role": "assistant", "content": ai_response.strip()})
-
-        query = dialog_parts[-1].split("\n")[0]
+        query = f"""{prompt.split("Human: ")[-1].strip()}"""
         return ans, query
 
     def _extract_observation(self, prompt: str):
@@ -90,25 +73,16 @@ class ChatGLM3(LLM):
         if len(self.history[-1]["metadata"]) > 0:
             metadata = self.history[-1]["metadata"]
             content = self.history[-1]["content"]
-
-            lines = content.split('\n')
-            for line in lines:
-                if 'tool_call(' in line and ')' in line and self.has_search is False:
-                    # 获取括号内的字符串
-                    params_str = line.split('tool_call(')[-1].split(')')[0]
-
-                    # 解析参数对
-                    params_pairs = [param.split("=") for param in params_str.split(",") if "=" in param]
-                    params = {pair[0].strip(): pair[1].strip().strip("'\"") for pair in params_pairs}
-                    action_json = {
-                        "action": metadata,
-                        "action_input": params
-                    }
-                    self.has_search = True
-                    print("*****Action*****")
-                    print(action_json)
-                    print("*****Answer*****")
-                    return f"""
+            if "tool_call" in content:
+                for tool in self.tool_names:
+                    if tool in metadata:
+                        input_para = content.split("='")[-1].split("'")[0]
+                        action_json = {
+                            "action": tool,
+                            "action_input": input_para
+                        }
+                        self.has_search = True
+                        return f"""
 Action: 
 ```
 {json.dumps(action_json, ensure_ascii=False)}
@@ -125,11 +99,17 @@ Action:
 ```"""
 
     def _call(self, prompt: str, history: List = [], stop: Optional[List[str]] = ["<|user|>"]):
+        print("======")
+        print(prompt)
+        print("======")
         if not self.has_search:
             self.history, query = self._tool_history(prompt)
         else:
             self._extract_observation(prompt)
             query = ""
+        # print("======")
+        # print(history)
+        # print("======")
         _, self.history = self.model.chat(
             self.tokenizer,
             query,

langchain_demo/README.md

+# README
+
+## 模型配置
+
+在 `main.py` 文件中，修改 `model_path = /path/to/chatglm3-6b` 路径，也可以填写 `THUDM/chatglm3-6b` 自动下载模型。
+
+## 工具添加
+
+### LangChain 已实现工具
+
+参考 [langchain](https://python.langchain.com/docs/modules/agents/tools/) 工具相关函数，在 `main.py` 中导入工具模块，例如导入 `arxiv` 工具
+
+```python
+run_tool(["arxiv"], llm, [
+    "帮我查询AgentTuning相关工作"
+])
+```
+
+#### Calculator、Weather Tool配置 
+
+如果你的 Python 环境中 `LangChain` 的版本低于  **`0.0.278`**  则需要在这两个预定义工具类中实现 `_arun` 方法
+否则将会出现 
+`TypeError: Can't instantiate abstract class Weather with abstract method _arun`
+
+示例如下：
+```python
+class Weather(BaseTool):
+    name = "weather"
+    description = "Use for searching weather at a specific location"
+
+    async def _arun(self, *args: Any, **kwargs: Any) -> Any:
+        # 用例中没有用到 arun 不予具体实现
+        pass
+```
+
+运行 `main.py` 文件
+
+```
+python main.py
+```
+
+模型会因找不到 `arxiv` 工具的 yaml 文件描述而中断，需要用户手动构建 `./Tool/arxiv.yaml` 文件。工具可以用户自行描述，也可以参考 LangChain 对该工具的描述。
+
+对 `arxiv` 这个例子而言，参考内容位于 `./Tool/arxiv_example.yaml` 文件，可参考该文件构建 `Tool/arxiv.yaml` 文件（最简单的方式修改名称即可），重新运行模型就能合理调用工具。
+
+> 有些工具需要导入 API_KEY，按照 langchain 报错添加到环境变量即可。
+
+### 自定义工具
+
+如果用户想自定义工具，可以参考 `Tool/Weather.py` 以及 `Tool/Weather.yaml` 文件，重载新的 `Tool` 类，实现其对应的 `_run()` 方法，然后在 `main.py` 中导入该工具模块，例如导入 `Weather` 工具，即可以调用
+
+```python
+# 对同一个工具调用多次
+# 需要 export SENIVERSE_KEY=<YOUR_API_KEY_HERE>
+run_tool([Weather()], llm, [
+        "今天北京天气怎么样？",
+        "What's the weather like in Shanghai today",
+])
+```
+
+## 多工具使用
+
+可以将多个工具组装在一起让模型自动选择调用，例如
+
+```python
+run_tool([Calculator(), "arxiv", Weather()], llm, [
+        "帮我检索GLM-130B相关论文",
+        "今天北京天气怎么样？",
+        "根号3减去根号二再加上4等于多少？",
+])
+```

langchain_demo/Tool/Calculator.py

+import abc
+import math
+from typing import Any
+
+from langchain.tools import BaseTool
+
+
+class Calculator(BaseTool, abc.ABC):
+    name = "Calculator"
+    description = "Useful for when you need to answer questions about math"
+
+    def __init__(self):
+        super().__init__()
+
+    async def _arun(self, *args: Any, **kwargs: Any) -> Any:
+        # 用例中没有用到 arun 不予具体实现
+        pass
+
+
+    def _run(self, para: str) -> str:
+        para = para.replace("^", "**")
+        if "sqrt" in para:
+            para = para.replace("sqrt", "math.sqrt")
+        elif "log" in para:
+            para = para.replace("log", "math.log")
+        return eval(para)
+
+
+if __name__ == "__main__":
+    calculator_tool = Calculator()
+    result = calculator_tool.run("sqrt(2) + 3")
+    print(result)

langchain_demo/Tool/Calculator.yaml

+name: Calculator
+description: Useful for when you need to answer questions about math
+parameters:
+  type: object
+  properties:
+    formula:
+      type: string
+      description: The formula to be calculated
+  required:
+    - formula
\ No newline at end of file

langchain_demo/tools/Weather.py → langchain_demo/Tool/Weather.py

 import os
-import requests
+from typing import Any
 
-from typing import Type, Any
+import requests
 from langchain.tools import BaseTool
-from pydantic import BaseModel, Field
-
-class WeatherInput(BaseModel):
-    location: str = Field(description="the location need to check the weather")
 
 
 class Weather(BaseTool):
     name = "weather"
     description = "Use for searching weather at a specific location"
-    args_schema: Type[BaseModel] = WeatherInput
 
     def __init__(self):
         super().__init__()
 
-    def _run(self, location: str) -> dict[str, Any]:
+    async def _arun(self, *args: Any, **kwargs: Any) -> Any:
+        # 用例中没有用到 arun 不予具体实现
+        pass
+
+    def get_weather(self, location):
         api_key = os.environ["SENIVERSE_KEY"]
         url = f"https://api.seniverse.com/v3/weather/now.json?key={api_key}&location={location}&language=zh-Hans&unit=c"
         response = requests.get(url)
@@ -31,3 +30,12 @@ class Weather(BaseTool):
         else:
             raise Exception(
                 f"Failed to retrieve weather: {response.status_code}")
+
+    def _run(self, para: str) -> str:
+        return self.get_weather(para)
+
+
+if __name__ == "__main__":
+    weather_tool = Weather()
+    weather_info = weather_tool.run("成都")
+    print(weather_info)

langchain_demo/Tool/arxiv_example.yaml

+name: arxiv
+description: A wrapper around Arxiv.org for searching and retrieving scientific articles in various fields.
+parameters:
+  type: object
+  properties:
+    query:
+      type: string
+      description: The search query title
+required:
+  - query
\ No newline at end of file

langchain_demo/Tool/weather.yaml

+name: weather
+description: Search the current weather of a city
+parameters:
+  type: object
+  properties:
+    city:
+      type: string
+      description: City name
+  required:
+    - city
\ No newline at end of file

langchain_demo/main.py

-"""
-This script demonstrates the use of the LangChain's StructuredChatAgent and AgentExecutor alongside various tools
-
-The script utilizes the ChatGLM3 model, a large language model for understanding and generating human-like text.
-The model is loaded from a specified path and integrated into the chat agent.
-
-Tools:
-- Calculator: Performs arithmetic calculations.
-- Weather: Provides weather-related information based on input queries.
-- DistanceConverter: Converts distances between meters, kilometers, and feet.
-
-The agent operates in three modes:
-1. Single Parameter without History: Uses Calculator to perform simple arithmetic.
-2. Single Parameter with History: Uses Weather tool to answer queries about temperature, considering the
-conversation history.
-3. Multiple Parameters without History: Uses DistanceConverter to convert distances between specified units.
-4. Single use Langchain Tool: Uses Arxiv tool to search for scientific articles.
-
-Note:
-The model calling tool fails, which may cause some errors or inability to execute. Try to reduce the temperature
-parameters of the model, or reduce the number of tools, especially the third function.
-The success rate of multi-parameter calling is low. The following errors may occur:
-
-Required fields [type=missing, input_value={'distance': '30', 'unit': 'm', 'to': 'km'}, input_type=dict]
-
-The model illusion in this case generates parameters that do not meet the requirements.
-The top_p and temperature parameters of the model should be adjusted to better solve such problems.
-
-Success example:
-
-*****Action*****
-
-{
-    'action': 'weather',
-    'action_input': {
-        'location': '厦门'
-        }
-}
-
-*****Answer*****
-
-{
-    'input': '厦门比北京热吗?',
-    'chat_history': [HumanMessage(content='北京温度多少度'), AIMessage(content='北京现在12度')],
-    'output': '根据最新的天气数据，厦门今天的气温为18度，天气晴朗。而北京今天的气温为12度。所以，厦门比北京热。'
-}
-
-****************
-
-"""
-
 import os
-
-from langchain import hub
-from langchain.agents import AgentExecutor, create_structured_chat_agent, load_tools
-from langchain_core.messages import AIMessage, HumanMessage
-
+from typing import List
 from ChatGLM3 import ChatGLM3
-from tools.Calculator import Calculator
-from tools.Weather import Weather
-from tools.DistanceConversion import DistanceConverter
-
-MODEL_PATH = os.environ.get('MODEL_PATH', 'THUDM/chatglm3-6b')
-
-if __name__ == "__main__":
-    llm = ChatGLM3()
-    llm.load_model(MODEL_PATH)
-    prompt = hub.pull("hwchase17/structured-chat-agent")
-
-    # for single parameter without history
 
-    tools = [Calculator()]
-    agent = create_structured_chat_agent(llm=llm, tools=tools, prompt=prompt)
-    agent_executor = AgentExecutor(agent=agent, tools=tools)
-    ans = agent_executor.invoke({"input": "34 * 34"})
-    print(ans)
+from langchain.agents import load_tools
+from Tool.Weather import Weather
+from Tool.Calculator import Calculator
+from langchain.agents import initialize_agent
+from langchain.agents import AgentType
 
-    # for singe parameter with history
+MODEL_PATH = os.environ.get('MODEL_PATH', 'THUDM/chatglm3-6b')
 
-    tools = [Weather()]
-    agent = create_structured_chat_agent(llm=llm, tools=tools, prompt=prompt)
-    agent_executor = AgentExecutor(agent=agent, tools=tools)
-    ans = agent_executor.invoke(
-        {
-            "input": "厦门比北京热吗?",
-            "chat_history": [
-                HumanMessage(content="北京温度多少度"),
-                AIMessage(content="北京现在12度"),
-            ],
-        }
+def run_tool(tools, llm, prompt_chain: List[str]):
+    loaded_tolls = []
+    for tool in tools:
+        if isinstance(tool, str):
+            loaded_tolls.append(load_tools([tool], llm=llm)[0])
+        else:
+            loaded_tolls.append(tool)
+    agent = initialize_agent(
+        loaded_tolls, llm,
+        agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
+        verbose=True,
+        handle_parsing_errors=True
     )
-    print(ans)
-
-    # for multiple parameters without history
-
-    tools = [DistanceConverter()]
-    agent = create_structured_chat_agent(llm=llm, tools=tools, prompt=prompt)
-    agent_executor = AgentExecutor(agent=agent, tools=tools)
-    ans = agent_executor.invoke({"input": "how many meters in 30 km?"})
-
-    print(ans)
+    for prompt in prompt_chain:
+        agent.run(prompt)
 
-    # for using langchain tools
 
-    tools = load_tools(["arxiv"], llm=llm)
-    agent = create_structured_chat_agent(llm=llm, tools=tools, prompt=prompt)
-    agent_executor = AgentExecutor(agent=agent, tools=tools)
-    ans = agent_executor.invoke({"input": "Describe the paper about GLM 130B"})
-
-    print(ans)
+if __name__ == "__main__":
+    llm = ChatGLM3()
+    llm.load_model(model_name_or_path=MODEL_PATH)
+
+    # arxiv: 单个工具调用示例 1
+    run_tool(["arxiv"], llm, [
+        "帮我查询GLM-130B相关工作"
+    ])
+
+    # weather: 单个工具调用示例 2
+    run_tool([Weather()], llm, [
+        "今天北京天气怎么样？",
+        "What's the weather like in Shanghai today",
+    ])
+
+    # calculator: 单个工具调用示例 3
+    run_tool([Calculator()], llm, [
+        "12345679乘以54等于多少？",
+        "3.14的3.14次方等于多少？",
+        "根号2加上根号三等于多少？",
+    ]),
+
+    # arxiv + weather + calculator: 多个工具结合调用
+    # run_tool([Calculator(), "arxiv", Weather()], llm, [
+    #     "帮我检索GLM-130B相关论文",
+    #     "今天北京天气怎么样？",
+    #     "根号3减去根号二再加上4等于多少？",
+    # ])
\ No newline at end of file

langchain_demo/requirements.txt

+langchain
+arxiv
\ No newline at end of file

langchain_demo/tools/Calculator.py

-import abc
-import re
-from typing import Type
-from langchain.tools import BaseTool
-from pydantic import BaseModel, Field
-
-
-class CalculatorInput(BaseModel):
-    calculation: str = Field(description="calculation to perform")
-
-
-class Calculator(BaseTool, abc.ABC):
-    name = "Calculator"
-    description = "Useful for when you need to calculate math problems"
-    args_schema: Type[BaseModel] = CalculatorInput
-
-    def __init__(self):
-        super().__init__()
-
-    def parameter_validation(self, para: str):
-        """
-        You can write your own parameter validation rules here,
-        you can refer to the code given here.
-        :param para:
-        :return:
-        """
-        symbols = ["math", "sqrt", "log", "sin", "cos", "tan", "pi"]
-        for sym in symbols:
-            para = para.replace(sym, "")
-        patten = re.compile("[+*/\-%\d()=\s.]{3,}")
-        if re.findall(patten, para):
-            return True
-
-    def _run(self, calculation: str) -> str:
-        calculation = calculation.replace("^", "**")
-        if "sqrt" in calculation and "math" not in calculation:
-            calculation = calculation.replace("sqrt", "math.sqrt")
-        if "log" in calculation and "math" not in calculation:
-            calculation = calculation.replace("log", "math.log")
-        if "sin" in calculation and "math" not in calculation:
-            calculation = calculation.replace("sin", "math.sin")
-        if "cos" in calculation and "math" not in calculation:
-            calculation = calculation.replace("cos", "math.cos")
-        if "tan" in calculation and "math" not in calculation:
-            calculation = calculation.replace("tan", "math.tan")
-        if "pi" in calculation and "math" not in calculation:
-            calculation = calculation.replace("pi", "math.pi")
-        if "pI" in calculation and "math" not in calculation:
-            calculation = calculation.replace("pI", "math.pi")
-        if "PI" in calculation and "math" not in calculation:
-            calculation = calculation.replace("PI", "math.pi")
-        if "Pi" in calculation and "math" not in calculation:
-            calculation = calculation.replace("Pi", "math.pi")
-        return eval(calculation)

langchain_demo/tools/DistanceConversion.py

-import abc
-from typing import Type
-from langchain.tools import BaseTool
-from pydantic import BaseModel, Field
-
-
-class DistanceConversionInput(BaseModel):
-    distance: float = Field(description="The numerical value of the distance to convert")
-    unit: str = Field(description="The current unit of the distance (m, km, or feet)")
-    to_unit: str = Field(description="The target unit to convert the distance into (m, km, or feet)")
-
-
-class DistanceConverter(BaseTool, abc.ABC):
-    name = "DistanceConverter"
-    description = "Converts distance between meters, kilometers, and feet"
-    args_schema: Type[BaseModel] = DistanceConversionInput
-
-    def __init__(self):
-        super().__init__()
-
-    def _run(self, distance: float, unit: str, to_unit: str) -> str:
-        unit_conversions = {
-            "m_to_km": 0.001,
-            "km_to_m": 1000,
-            "feet_to_m": 0.3048,
-            "m_to_feet": 3.28084,
-            "km_to_feet": 3280.84,
-            "feet_to_km": 0.0003048
-        }
-
-        if unit == to_unit:
-            return f"{distance} {unit} is equal to {distance} {to_unit}"
-
-        if unit == "km":
-            distance *= unit_conversions["km_to_m"]
-        elif unit == "feet":
-            distance *= unit_conversions["feet_to_m"]
-
-        if to_unit == "km":
-            converted_distance = distance * unit_conversions["m_to_km"]
-        elif to_unit == "feet":
-            converted_distance = distance * unit_conversions["m_to_feet"]
-        else:
-            converted_distance = distance  # already in meters if this block is reached
-
-        return f"{distance} {unit} is equal to {converted_distance} {to_unit}"

langchain_demo/utils.py

+import os
+import yaml
+
+
+def tool_config_from_file(tool_name, directory="Tool/"):
+    """search tool yaml and return json format"""
+    for filename in os.listdir(directory):
+        if filename.endswith('.yaml') and tool_name in filename:
+            file_path = os.path.join(directory, filename)
+            with open(file_path, encoding='utf-8') as f:
+                return yaml.safe_load(f)
+    return None

model.properties

+# 模型唯一标识
+modelCode=474
+# 模型名称
+modelName=chatglm3-6b_pytorch
+# 模型描述
+modelDescription=基于pytorch的chatglm3-6b
+# 应用场景
+appScenario=训练,推理,对话问答,医疗,教育,科研,金融
+# 框架类型
+frameType=Pytorch,Transformers,Deepspeed