AutoGPT与HuggingGPT实现原理剖析：也看大模型的自动化策略系统的代表工作

前些日子，AutoGPT以及HuggingGPT十分火爆，其通过ChatGPT大模型自动进行决策，并调用模型，可以实现高度的自动化决策，并拓宽大模型的应用外沿。

但最关键的，其具体实现原理如何，内部是如何运作的，对于我们认识它们尤为重要。

因此，本文主要围绕AutoGPT以及HuggingGPT，对其工作原理和代码进行阅读，供大家一起参考。

一、HuggingGPT工作原理概述

解决不同领域和模式的复杂人工智能任务是迈向高级人工智能的关键一步。虽然有丰富的人工智能模型可用于不同的领域和模式，但它们不能处理复杂的人工智能任务。

考虑到大型语言模型（LLMs）在语言理解、生成、交互和推理方面表现出的卓越能力，可以主张LLMs可以作为一个控制器来管理现有的人工智能模型，以解决复杂的人工智能任务，而语言可以作为一个通用接口来授权。

基于这一理念，HuggingGPT被提出，这是一个利用LLM（如ChatGPT）来连接机器学习社区（如Hugging Face）中各种人工智能模型的框架，以解决人工智能任务。

具体来说，使用ChatGPT在收到用户请求时进行任务规划，根据Hugging Face中的功能描述选择模型，用所选的AI模型执行每个子任务，并对响应情况进行总结。

受益于这样的设计，HuggingGPT能够使用外部模型，因此可以整合多模态感知能力，处理多个复杂的人工智能任务。

此外，该管道还允许HuggingGPT继续吸收特定任务专家的力量，实现可增长和可扩展的AI能力。 

到目前为止，HuggingGPT已经在ChatGPT周围的Hugging Face上集成了数百个模型，涵盖了24个任务，如文本分类、物体检测、语义分割、图像生成、问题回答、文本到语音和文本到视频。

实验结果证明了HuggingGPT在处理多模态信息和复杂人工智能任务方面的能力。

论文题目：《HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in HuggingFace》

论文地址：https://arxiv.org/abs/2303.17580

1、基本步骤

HuggingGPT的整个过程可以分为四个阶段：

给定输入：

1）Task Planning-任务规划

利用ChatGPT分析用户的请求，了解他们的意图，并通过提示将其分解为可能的可解决的任务。

在HuggingGPT的第一阶段，大型语言模型从用户那里获得请求，并将其分解为一连串结构化的任务。

复杂的请求往往涉及多个任务，大语言模型需要确定这些任务的依赖关系和执行顺序。

为了提示大语言模型进行有效的任务规划，HuggingGPT在其提示设计中同时采用了基于规范的指令和基于演示的解析两种方法。

其中，基于规范的指令：

任务规范为任务提供了一个统一的模板，并允许大语言模型通过槽的归档来进行任务解析。

HuggingGPT为任务解析设计了四个槽，分别是任务类型、任务ID、任务依赖关系和任务参数：

• 任务ID为任务规划提供唯一的标识符，用于引用依赖任务及其生成的资源。
• 任务类型涵盖了语言、视觉、视频、音频等方面的不同任务。
• 任务的依赖性定义了执行所需的前提任务。只有当所有的前提依赖任务都完成后，任务才会启动。
• 任务参数包含任务执行所需参数的列表。它包含三个子字段，根据任务类型填充了文本、图像和音频资源。它们从用户的请求或从属任务的生成资源中解决。
• 如下表所示

最终的prompt如下：

HuggingGPT将这些任务规范作为高级指令提供给大语言模型，用于分析用户的请求并相应地解析任务。

例如：

针对text : “Look at /exp1.jpg, Can you tell me how many objects in the picture?”

得到的解析结果为：

[
    {
      "task": "image-to-text",
      "id": 0, "dep": [-1], 
      "args": {"image": "/exp1.jpg"}
    }, 
{
    "task": "object-detection",
    "id": 0,
    "dep": [-1], 
    "args": {"image": "/exp1.jpg" }
}
]

针对text:”In /exp2.jpg, what’s the ani- mal and what’s it doing?”

得到的解析结果为：

[
  {
  "task": "image-to-text", 
  "id": 0, "dep":[-1], 
  "args": {"image": "/exp2.jpg" }
  }, 
  {
  "task":"image-classification",
  "id": 1, "dep": [-1], 
  "args": {"image": "/exp2.jpg" }
  },
  {
  "task":"object-detection", 
  "id": 2,
  "dep": [-1],
  "args": {"image": "/exp2.jpg" }
  }, 
  {
  "task": "visual- question-answering", 
  "id": 3, 
  "dep":[-1], 
  "args": {"text": "What’s the animal doing?", 
  "image": "/exp2.jpg" }
}]

此外，对话的上下文管理对聊天机器人至关重要，因为它提供了聊天记录，以促进对用户请求的理解。

2）Model selection-模型选择

为了解决计划中的任务，ChatGPT根据模型描述，选择托管在Hugging Face上的专家模型。

在解析了任务列表后，HuggingGPT接下来需要匹配任务和模型，即为任务列表中的每个任务选择合适的模型。

为此，首先从Hugging Face Hub获得专家模型的描述，然后通过上下文任务-模型分配机制为任务动态地选择模型。

这种做法允许渐进式的模型访问（只需提供专家模型的描述），并且更加开放和灵活。

在具体实现上，根据任务类型过滤模型，只保留那些与当前任务类型相匹配的模型，然后根据模型在huggingface上的下载量对剩下的模型进行排名，然后根据这个排名选择前K名的模型作为HuggingGPT的候选者，供其选择，如下所示：

https://raw.githubusercontent.com/microsoft/JARVIS/2c19142b56663a54b2c85f8622b38f98c5b2580f/server/data/p0_models.jsonl

该模型中存储了关于模型接口的一些基本信息，可以作为候选model。

{

"downloads": 1677372, 

"id": "ProsusAI/finbert",

"likes": 186, 

"pipeline_tag": "text-classification",

"task": "text-classification", 

"meta": {"language": "en", "tags": ["financial-sentiment-analysis", "sentiment-analysis"], "widget": [{"text": "Stocks rallied and the British pound gained."}]}, 

"description": "nnFinBERT is a pre-trained NLP model to analyze sentiment of financial text. It is built by further training the BERT language model in the finance domain, using a large financial corpus and thereby fine-tuning it for financial sentiment classification. [Financial PhraseBank](https://www.researchgate.net/publication/251231107_Good_Debt_or_Bad_Debt_Detecting_Semantic_Orientations_in_Economic_Texts) by Malo et al. (2014) is used for fine-tuning. For more details, please see the paper [FinBERT: Financial Sentiment Analysis with Pre-trained Language Models](https://arxiv.org/abs/1908.10063) and our related [blog post](https://medium.com/prosus-ai-tech-blog/finbert-financial-sentiment-analysis-with-bert-b277a3607101) on Medium.nnThe model will give softmax outputs for three labels: positive, negative or neutral.nn"

}

3）Task execution-任务执行

调用并执行每个选定的模型，并将结果返回给ChatGPT。

一旦一个任务被分配给一个特定的模型，下一步就是执行任务，即进行模型推理。

为了提高速度和计算稳定性，HuggingGPT在混合推理端点上运行这些模型。通过将任务参数作为输入，模型计算推理结果，然后将其送回大语言模型。

def huggingface_model_inference(model_id, data, task):
    task_url = f"https://api-inference.huggingface.co/models/{model_id}" # InferenceApi does not yet support some tasks
    inference = InferenceApi(repo_id=model_id, token=config["huggingface"]["token"])
    # NLP tasks
    if task == "question-answering":
        inputs = {"question": data["text"], "context": (data["context"] if "context" in data else "" )}
        result = inference(inputs)
    if task == "sentence-similarity":
        inputs = {"source_sentence": data["text1"], "target_sentence": data["text2"]}
        result = inference(inputs)
    if task in ["text-classification",  "token-classification", "text2text-generation", "summarization", "translation", "conversational", "text-generation"]:
        inputs = data["text"]
        result = inference(inputs)
    
    # CV tasks
    if task == "visual-question-answering" or task == "document-question-answering":
        img_url = data["image"]
        text = data["text"]
        img_data = image_to_bytes(img_url)
        img_base64 = base64.b64encode(img_data).decode("utf-8")
        json_data = {}
        json_data["inputs"] = {}
        json_data["inputs"]["question"] = text
        json_data["inputs"]["image"] = img_base64
        result = requests.post(task_url, headers=HUGGINGFACE_HEADERS, json=json_data).json()
        # result = inference(inputs) # not support

为了进一步提高推理效率，没有资源依赖性的模型可以被并行化，这意味着满足了前提依赖的多个任务可以同时启动。

        # image to text
        if model_id == "Salesforce/blip-image-captioning-large":
            raw_image = load_image(request.get_json()["img_url"]).convert('RGB')
            text = request.get_json()["text"]
            inputs = pipes[model_id]["processor"](raw_image, return_tensors="pt").to(pipes[model_id]["device"])
            out = pipe.generate(**inputs)
            caption = pipes[model_id]["processor"].decode(out[0], skip_special_tokens=True)
            result = {"generated text": caption}
        # text to image
        if model_id == "runwayml/stable-diffusion-v1-5":
            file_name = str(uuid.uuid4())[:4]
            text = request.get_json()["text"]
            out = pipe(prompt=text)
            out["images"][0].save(f"public/images/{file_name}.jpg")
            result = {"path": f"/images/{file_name}.jpg"}

        # VQA
        if model_id == "dandelin/vilt-b32-finetuned-vqa":
            question = request.get_json()["text"]
            img_url = request.get_json()["img_url"]
            result = pipe(question=question, image=img_url)

        #DQA
        if model_id == "impira/layoutlm-document-qa":
            question = request.get_json()["text"]
            img_url = request.get_json()["img_url"]
            result = pipe(img_url, question)

4）Response generation-响应生成

最后，使用ChatGPT整合所有模型的预测结果，为用户生成答案。

其核心在于将上述各个阶段的结果都罗列并形成prompt，最终作为摘要模型进行生成。

所有任务执行完成后，HuggingGPT 进入响应生成阶段。

在这个阶段，HuggingGPT将前三个阶段（任务规划、模型选择和任务执行）的所有信息整合成一个简洁的摘要，包括计划中的任务列表、为任务选择的模型以及模型的推理结果。

其中最重要的是推理结果，它是HuggingGPT做出最终决定的支持。

这些推理结果以结构化的格式出现，如物体检测模型中带有检测概率的边界框，问题回答模型中的答案分布等。

HuggingGPT允许LLM接收这些结构化的推理结果作为输入，并以友好的人类语言形式生成响应。

此外，LLM不是简单地汇总结果，而是生成积极响应用户请求的响应，提供具有置信度的可靠决定。

2、实现效果

在具体实验方面，采用了GPT模型的gpt-3.5-turbo和text-davinci-003变体作为大语言模型，这些模型可以通过OpenAI API 4公开访问。

 为了使LLM的输出更加稳定，将解码温度设置为0，同时为了调节LLM的输出符合预期格式，我们将格式约束的logit_bias设置为0.2。

​不过，考虑到用户请求可能包含多个隐含任务或需要多方面的信息，在这种情况下，不能依靠调用一个专家模型来解决。

为了克服这一挑战，HuggingGPT通过任务规划组织了多个模型的协作。

如： 在图3、4和5展示了几个对话演示，在每个演示中，用户输入一个可能包含多个任务或多模式资源的请求。然后HuggingGPT依靠LLM来组织多个专家模型的合作，以产生对用户的回应； 

我们可以发现，即使有多个资源，HuggingGPT也能将主要任务分解成多个基本任务，最后整合多个模型的推理结果，得到正确答案。

图3显示了HuggingGPT在任务之间存在资源依赖性的情况下的工作过程。在这种情况下，HuggingGPT可以根据用户的抽象请求解析出具体的任务，包括姿势检测、图像说明和姿势条件图像生成任务。

此外，HuggingGPT成功识别了任务3与任务1和2之间的依赖关系，并在依赖任务完成后将任务1和2的推断结果注入任务3的输入参数中。

在这两种情况下，它显示HuggingGPT分别通过专家模型完成了用户要求的文本到音频和文本到视频任务。在上面一个案例中，两个模型是平行执行的（同时生成音频和视频），而在下面一个案例中，两个模型是串行执行的（先从图像生成文本，然后根据文本生成音频）。

这进一步验证了HuggingGPT可以组织模型之间的合作和任务之间的资源依赖性。

图6和图7展示了广泛的多模态任务上测试了HuggingGPT；

图8、9和10测试以评估HuggingGPT在复杂任务中的有效性。 用户将一个复杂的请求分成几个步骤，通过多轮请求达到最终目标。

可以发现，HuggingGPT可以通过任务规划阶段的对话情境管理来跟踪用户请求的情境状态，并且可以很好地解决用户提到的资源以及任务规划。

3、一个简单的复现项目

ALL-IN-ONE: A Reproduction of HuggingGPT

由于chatGPT在国内无法合法访问，且访问huggingface的仓库容易掉线，而下载并运行这些模型会耗费大量资源，该项目使用chatGLM替换chatGPT，使用百度Ai的api替换huggingface的各个模型，实现了对HuggingGPT的复现。

优点是占用资源小，响应速度快。缺点是功能相对少，因为百度Ai的模型显然是比huggingface的少。

https://github.com/SolarWindRider/All-In-One

二、AutoGPT工作原理概述

博客(地址：https://www.zhihu.com/question/595382995/answer/2985265957)中对AutoGPT有个很形象的比喻：

如果把使用模型的场景比喻成开车的话。

第一阶段的基础模型相当于一本地图集，上面蕴含了大量信息，但是需要查时候还得手动翻目录去查；

第二阶段的对话模型相当于导航软件，输入我们想要去的目的地之后，导航会告诉你怎么走，但车还得自己开；

第三阶段的应用集成相当于一辆自动驾驶汽车，只要输入我们的目的地，就能直接到达了。

AutoGPT就是这辆自动驾驶汽车。

AutoGPT其核心在于把我们的命令发送给GPT-4的时候，让GPT-4根据指定的COMMAND来选择操作。

例如，AutoGPT会把问题，如“寻找今天推特上最火的AI推文”发给GPT-4，并要求GPT-4根据这些COMMAND选择最合适的方式去得到答案，并给出每一个COMMAND背后需要使用的参数，包括URL、执行的代码，然后AutoGPT根据返回的结果来使用想用的命令执行GPT-4的建议。

如下图所示，显示了用户从提供目标和任务后的整个数据流。

在实现原理上，AutoGPT共包括几步：

1、提出问题，即设定一个目标；

2、AutoGPT 根据设定的目标，拆解主任务；

3、分别并执行各个主任务，然后得到结果；

4、当主任务执行完成后，会执行额外的添加的子任务。

上图给出了整体的源代码，其中，有个核心就是对应的prompt，

在”./data/prompt.txt”文件中可以看到。

CONSTRAINTS:

1. ~4000 word limit for short term memory. Your short term memory is short, so immediately save important information to files.
2. If you are unsure how you previously did something or want to recall past events, thinking about similar events will help you remember.
3. No user assistance
4. Exclusively use the commands listed in double quotes e.g. "command name"

COMMANDS:

1. Google Search: "google", args: "input": "<search>"
5. Browse Website: "browse_website", args: "url": "<url>", "question": "<what_you_want_to_find_on_website>"
6. Start GPT Agent: "start_agent",  args: "name": "<name>", "task": "<short_task_desc>", "prompt": "<prompt>"
7. Message GPT Agent: "message_agent", args: "key": "<key>", "message": "<message>"
8. List GPT Agents: "list_agents", args: ""
9. Delete GPT Agent: "delete_agent", args: "key": "<key>"
10. Write to file: "write_to_file", args: "file": "<file>", "text": "<text>"
11. Read file: "read_file", args: "file": "<file>"
12. Append to file: "append_to_file", args: "file": "<file>", "text": "<text>"
13. Delete file: "delete_file", args: "file": "<file>"
14. Search Files: "search_files", args: "directory": "<directory>"
15. Evaluate Code: "evaluate_code", args: "code": "<full_code_string>"
16. Get Improved Code: "improve_code", args: "suggestions": "<list_of_suggestions>", "code": "<full_code_string>"
17. Write Tests: "write_tests", args: "code": "<full_code_string>", "focus": "<list_of_focus_areas>"
18. Execute Python File: "execute_python_file", args: "file": "<file>"
19. Task Complete (Shutdown): "task_complete", args: "reason": "<reason>"
20. Generate Image: "generate_image", args: "prompt": "<prompt>"
21. Do Nothing: "do_nothing", args: ""

RESOURCES:

1. Internet access for searches and information gathering.
2. Long Term memory management.
3. GPT-3.5 powered Agents for delegation of simple tasks.
4. File output.

PERFORMANCE EVALUATION:

1. Continuously review and analyze your actions to ensure you are performing to the best of your abilities.
2. Constructively self-criticize your big-picture behavior constantly.
3. Reflect on past decisions and strategies to refine your approach.
4. Every command has a cost, so be smart and efficient. Aim to complete tasks in the least number of steps.

You should only respond in JSON format as described below

RESPONSE FORMAT:
{
    "thoughts":
    {
        "text": "thought",
        "reasoning": "reasoning",
        "plan": "- short bulletedn- list that conveysn- long-term plan",
        "criticism": "constructive self-criticism",
        "speak": "thoughts summary to say to user"
    },
    "command": {
        "name": "command name",
        "args":{
            "arg name": "value"
        }
    }
}

Ensure the response can be parsed by Python json.loads

主要的工作流程：

例如，给定‍‍‍

You are 我是GPT, LangChain如何使用 Your decisions must always be made independently without seeking user assistance. Play to your strengths as an LLM and pursue simple strategies with no legal complications. 

GOALS:

1. 告诉我LangChain如何使用.

2. 帮我安装LangChain.

3. 告诉我一些可以直接在我电脑上运行LangChain的例子.

4. 所有的问题都用中文回答.

会得到如下答案：

{
    "thoughts":{
        "text": "LangChain is a programming language that can be used for blockchain development. To use it, we need to first download and install it on our computer. After installation, we can run some code examples to test it out. ",
        "reasoning": "I reviewed the purpose and usage of LangChain and suggested a plan for installation and testing",
        "plan": "- Download and install LangChain.n- Run code examples to test it out.",
        "criticism": "I should have provided more specific detailed steps on how to download and install LangChain",
        "speak": "We need to download and install LangChain before we can use it. Do you have any experience with this?"
    },
    "command":{
        "name": "browse_website",
        "args":{
            "url": "https://langchain.org/docs/getting-started/",
            "question": "How to download and install LangChain?"
        }
    }
}

具体的完整流程如下：本质是一个循环。

# Make a constant:
user_input = "Determine which next command to use, and respond using the format specified above:"

# Initialize memory and make sure it is empty.
# this is particularly important for indexing and referencing pinecone memory
memory = get_memory(cfg, init=True)
print('Using memory of type: ' + memory.__class__.__name__)

# Interaction Loop
while True:
    # Send message to AI, get response
    with Spinner("Thinking... "):
        assistant_reply = chat.chat_with_ai(
            prompt,
            user_input,
            full_message_history,
            memory,
            cfg.fast_token_limit) # TODO: This hardcodes the model to use GPT3.5. Make this an argument

    # Print Assistant thoughts
    print_assistant_thoughts(assistant_reply)

    # Get command name and arguments
    try:
        command_name, arguments = cmd.get_command(assistant_reply)
    except Exception as e:
        print_to_console("Error: n", Fore.RED, str(e))

    if not cfg.continuous_mode and next_action_count == 0:
        ### GET USER AUTHORIZATION TO EXECUTE COMMAND ###
        # Get key press: Prompt the user to press enter to continue or escape
        # to exit
        user_input = ""
        print_to_console(
            "NEXT ACTION: ",
            Fore.CYAN,
            f"COMMAND = {Fore.CYAN}{command_name}{Style.RESET_ALL}  ARGUMENTS = {Fore.CYAN}{arguments}{Style.RESET_ALL}")
        print(
            f"Enter 'y' to authorise command, 'y -N' to run N continuous commands, 'n' to exit program, or enter feedback for {ai_name}...",
            flush=True)
        while True:
            console_input = utils.clean_input(Fore.MAGENTA + "Input:" + Style.RESET_ALL)
            if console_input.lower() == "y":
                user_input = "GENERATE NEXT COMMAND JSON"
                break
            elif console_input.lower().startswith("y -"):
                try:
                    next_action_count = abs(int(console_input.split(" ")[1]))
                    user_input = "GENERATE NEXT COMMAND JSON"
                except ValueError:
                    print("Invalid input format. Please enter 'y -n' where n is the number of continuous tasks.")
                    continue
                break
            elif console_input.lower() == "n":
                user_input = "EXIT"
                break
            else:
                user_input = console_input
                command_name = "human_feedback"
                break

        if user_input == "GENERATE NEXT COMMAND JSON":
            print_to_console(
            "-=-=-=-=-=-=-= COMMAND AUTHORISED BY USER -=-=-=-=-=-=-=",
            Fore.MAGENTA,
            "")
        elif user_input == "EXIT":
            print("Exiting...", flush=True)
            break
    else:
        # Print command
        print_to_console(
            "NEXT ACTION: ",
            Fore.CYAN,
            f"COMMAND = {Fore.CYAN}{command_name}{Style.RESET_ALL}  ARGUMENTS = {Fore.CYAN}{arguments}{Style.RESET_ALL}")

    # Execute command
    if command_name is not None and command_name.lower().startswith( "error" ):
        result = f"Command {command_name} threw the following error: " + arguments
    elif command_name == "human_feedback":
        result = f"Human feedback: {user_input}"
    else:
        result = f"Command {command_name} returned: {cmd.execute_command(command_name, arguments)}"
        if next_action_count > 0:
            next_action_count -= 1

    memory_to_add = f"Assistant Reply: {assistant_reply} " 
                    f"nResult: {result} " 
                    f"nHuman Feedback: {user_input} "

    memory.add(memory_to_add)

    # Check if there's a result from the command append it to the message
    # history
    if result is not None:
        full_message_history.append(chat.create_chat_message("system", result))
        print_to_console("SYSTEM: ", Fore.YELLOW, result)
    else:
        full_message_history.append(
            chat.create_chat_message(
                "system", "Unable to execute command"))
        print_to_console("SYSTEM: ", Fore.YELLOW, "Unable to execute command")

总结

本文主要介绍了AutoGPT与HuggingGPT两个决策模型。

我们最后来看看区别：

HuggingGPT的目的是使用所有的AI模型接口完成一个复杂的特定的任务，更像解决一个技术问题的方案。

AutoGPT更像一个决策机器人，它可以执行的动作范围比AI模型要更多样，因为它集成了谷歌搜索、浏览网页、执行代码等能力。

但这两种模型的思想很灵活，我之前还想着用知识图谱作为强规则融入其中，看来也是可行的。

参考文献

1、https://arxiv.org/pdf/2303.17580.pdf
2、https://zhuanlan.zhihu.com/p/621217077

​关于我们

老刘，刘焕勇，NLP开源爱好者与践行者，主页：https://liuhuanyong.github.io。

老刘说NLP，将定期发布语言资源、工程实践、技术总结等内容，欢迎关注。

对于想加入更优质的知识图谱、事件图谱实践、相关分享的，可关注公众号，在后台菜单栏中点击会员社区->会员入群加入。