Long text processing method and system based on introspection mechanism, computer and medium
By introducing introspection mechanism and proxy decomposition technology in long text processing, the efficiency and accuracy problems of the existing technology when dealing with complex and variable web pages are solved, and efficient and reliable long text processing effects are achieved.
Patent Information
- Application Number
- CN202411944320.2
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-12-27
- Publication Date
- 2025-04-18
AI Technical Summary
The prior art is difficult to achieve efficient and accurate processing when processing long text, especially complex and variable web pages, and lacks reliability and precision.
A long text processing method based on the introspection mechanism is adopted. By constructing a task planning agent and a browser proxy, the user tasks are decomposed into multiple subtasks, and the browser text is extracted through the browser proxy. At the same time, a self-reflection feedback mechanism is introduced to determine the task execution results through the discriminator and optimize the task planning and execution.
It realizes efficient processing of complex and variable web pages, improves the accuracy and reliability of processing, and optimizes the task planning and execution process through self-reflection and feedback mechanism.
Smart Images
Figure CN119848377A_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the field of data processing technology, and in particular to a long text processing method, system, computer and medium based on an introspection mechanism. Background Art
[0002] The rapid development of Large Language Models (LLMs) in recent years has opened up many possibilities for AI. Some of the famous LLMs are GPT-3, GPT-4, PaLM, LLaMA, and Qwen. These models have great potential in understanding, generating, and applying natural language. These advances have created a medium for LLM-powered agents, which are now being developed to solve problems in search engines, software engineering, games, recommender systems, and scientific experiments. These agents are often guided by Chains of Thought (CoT) like ReAct and have access to tools such as APIs, code interpreters, and retrievers.
[0003] A significant challenge in processing long texts with large language models is the computational burden and associated costs. A promising approach is retrieval-augmented generation, which retrieves relevant information based on a query and prompts a large language model to generate a response in that context. Retrieval-augmented generation can significantly expand the model's ability to access long texts in an economical manner. However, retrieval-augmented generation still has shortcomings. In the process of processing long texts, it mainly relies on plain text as context. For web pages with complexity and variability, retrieval-augmented production usually cannot perform tasks accurately and lacks reliability and precision. Summary of the invention
[0004] In view of the deficiencies of the above-mentioned prior art, the technical problem to be solved by the present invention is: a long text processing method, system, computer and medium based on an introspection mechanism are proposed, aiming to realize the step-by-step planning of user tasks through a task planning agent; through a browser agent, it is possible to call the corresponding DOM method according to each subtask in the step-by-step planning, so as to extract the browser text; through the task planning agent and the browser agent, it is possible to cope with web pages with complexity and variability.
[0005] In order to solve the above technical problems, a technical solution adopted by the present invention is: to provide a long text processing method based on an introspection mechanism, comprising the following steps:
[0006] S1: Build task planning agent and browser agent based on the pre-trained large language model;
[0007] S2: In response to the user's new task, the task planning agent decomposes the user's new task into multiple subtasks and outputs a task list;
[0008] S3: the browser agent selects the corresponding perception function to execute each subtask in turn according to each subtask in the task list, and returns the task execution result after each subtask is executed;
[0009] S4: The discriminator judges the rationality of the response and planning of each task execution result and the subtask corresponding to the task execution result, and optimizes the task planning and task execution process according to the judgment result.
[0010] Furthermore, the step S1 comprises the following steps:
[0011] S11: constructing a task planning agent according to the pre-trained large language model, including a task planner and a task planning executor, wherein the task planner outputs a function or interface required to complete the task planning according to the user's new task, and the task planning executor performs task planning for the user's new task by calling the function or interface;
[0012] S12: Based on the pre-trained large language model, a browser agent is constructed, including a browser navigation planner and a browser navigation executor. The browser navigation planner outputs the DOM method called by the browser navigation according to the task plan, and the browser navigation executor extracts the browser content according to the DOM method.
[0013] Furthermore, the step S2 comprises the following steps:
[0014] S21: The task planner identifies the text type of the user's new task, and outputs the interface or function required to be called for planning the user's new task according to the text type;
[0015] S22: The task executor decomposes the text of the new task of the user according to the interface or function that is output by the task planner and is required to be called for planning the new task of the user, and forms a plurality of subtasks.
[0016] Furthermore, the step S3 comprises the following steps:
[0017] S31: The browser navigation planner identifies each subtask in the task plan and outputs the DOM method required to be called to execute each subtask;
[0018] S32: The browser navigation executor calls the DOM method to perceive or extract the browser content.
[0019] Furthermore, the step S4 comprises the following steps:
[0020] S41: training a discriminator using a training set, where the training set includes a data set with reasonableness annotated for task execution results and task planning;
[0021] S42: the discriminator obtains each execution result executed by the browser navigation executor and the subtask corresponding to each execution result, and outputs the determination result;
[0022] S43: If the determination result is positive, the corresponding execution result is directly output; if the determination result is negative, the determination result is input into the task planner to re-plan the task.
[0023] Furthermore, after step S4, the following steps are also included:
[0024] S5: When the browser navigation executor executes the subtasks in sequence, if the human-machine verification operation is triggered on the browser side, the task execution summary is returned to the user.
[0025] In order to solve the above technical problems, the second technical solution adopted by the present invention is to provide a long text processing system based on an introspection mechanism, comprising:
[0026] The agent building module is used to build task planning agents and browser agents based on the pre-trained large language model;
[0027] A task planning module, used for responding to a new task from a user, wherein the task planning agent decomposes the new task from the user into a plurality of subtasks and outputs a task list;
[0028] A subtask execution module, used for the browser agent to select the corresponding perception function to execute each subtask in turn according to each subtask in the task list, and return the task execution result after each subtask is executed;
[0029] The introspection feedback module is used to judge the rationality of the response and planning of each task execution result and the subtask corresponding to the task execution result through the discriminator, and optimize the task planning and task execution process according to the judgment results.
[0030] Furthermore, the agent building module includes:
[0031] The task planning agent construction submodule is used to construct a task planning agent according to the pre-trained large language model, including a task planner and a task planning executor. The task planner outputs the function or interface required to complete the task planning according to the user's new task, and the task planning executor performs task planning for the user's new task by calling the function or interface.
[0032] The browser agent construction submodule is used to construct a browser agent according to the pre-trained large language model, including a browser navigation planner and a browser navigation executor. The browser navigation planner outputs the DOM method called by the browser navigation according to the task plan, and the browser navigation executor extracts the browser content according to the DOM method.
[0033] To solve the above technical problems, the third technical solution adopted by the present invention is: a computer device, comprising: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement any of the long text processing methods described above.
[0034] To solve the above technical problems, the fourth technical solution adopted by the present invention is: a computer-readable storage medium having a computer program stored thereon, and the computer program implements any of the above-mentioned long text processing methods when executed by a processor.
[0035] The long text processing method, system, computer and medium based on the introspection mechanism of the present invention have at least the following beneficial effects: the present invention can realize the step-by-step planning of user tasks through the task planning agent; through the browser agent, the corresponding DOM method can be called according to each subtask in the step-by-step planning, so as to extract the browser text; through the task planning agent and the browser agent, web pages with complexity and variability can be handled; through the introspection feedback mechanism, the task planning can be judged and optimized; through the human-computer collaboration mode, when the human-computer verification operation is triggered, the task execution summary is returned to the user. BRIEF DESCRIPTION OF THE DRAWINGS
[0036] The drawings described herein are used to provide a further understanding of the present application and constitute a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation on the present application. In the drawings:
[0037] Figure 1 It is a flow chart of an implementation method of a long text processing method based on the introspection mechanism of the present invention.
[0038] Figure 2 for Figure 1 Sub-flow chart of step S1 in .
[0039] Figure 3 for Figure 1 Sub-flow chart of step S2 in .
[0040] Figure 4 for Figure 1 Sub-flow chart of step S3 in .
[0041] Figure 5for Figure 1 Sub-flow chart of step S4 in .
[0042] Figure 6 It is a structural block diagram of an implementation scheme of a long text processing system of the present invention. DETAILED DESCRIPTION
[0043] The present invention will be further described below in conjunction with the accompanying drawings.
[0044] See also Figure 1 , is a flow chart of an embodiment of a method, system, computer and medium for processing long text based on introspection mechanism of the present invention. This embodiment may specifically include the following steps:
[0045] S1: Build a task planning agent and a browser agent based on the pre-trained large language model.
[0046] Specifically, the embodiment of the present invention adopts a task planning agent and a browser agent to process long text in the browser, which can handle web pages with complexity and variability. Its core is mainly two components based on the large language model: the planning agent and the browser navigation agent. Each LLM-based agent is associated with some skills, which are Python functions and are described to the LLM for function calls. Then, the function suggested by the LLM is executed through the executor component, and the response is transmitted back to the LLM.
[0047] In some embodiments, see Figure 2 , this step S1 may include the following sub-steps:
[0048] S11: Based on the pre-trained large language model, a task planning agent is constructed, including a task planner and a task planning executor. The task planner outputs the function or interface required to complete the task planning according to the user's new task, and the task planning executor performs task planning for the user's new task by calling the function or interface.
[0049] Specifically, in this embodiment, the task planning agent includes a task planner and a task planning executor, wherein the task planner can output the function or interface required to complete the task planning according to the user's new task, and the task planning executor performs task planning for the user's new task by calling the function or interface.
[0050] S12: Based on the pre-trained large language model, a browser agent is constructed, including a browser navigation planner and a browser navigation executor. The browser navigation planner outputs the DOM method called by the browser navigation according to the task plan, and the browser navigation executor extracts the browser content according to the DOM method.
[0051] Specifically, similar to the above-mentioned task planning agent, the difference between the browser agent and the browser agent is that the browser agent is mainly used to extract the long text of the browser according to the task planning. In this embodiment, the planner is mainly used to plan the method, interface or function that the executor needs to call according to the input, and the executor is mainly used to execute the above-mentioned method, interface or function. In this way, the task planning agent can identify the text data input by the user, and plan the method, interface or function that needs to be called in its task decomposition process through the task planner, and call the method, interface or function through the task planning executor to realize the decomposition and planning of the task; while the browser agent can identify the task planning, and plan the method, interface or function that needs to be called for each subtask in the task planning through the browser navigation planner (for browser text processing, various DOM methods are commonly used), and then execute through the browser navigation executor to complete the long text processing of the browser.
[0052] S2: In response to the user's new task, the task planning agent decomposes the user's new task into multiple subtasks and outputs a task list.
[0053] Specifically, in this embodiment, given a new user task, the task planning agent decomposes the task into a series of steps to be executed, which can be called subtasks, and sorts the subtasks in order to generate a task plan. Then the next step is delegated to the browser navigation agent for execution.
[0054] In some embodiments, see Figure 3 , this step S2 may include the following steps:
[0055] S21: The task planner identifies the text type of the user's new task, and outputs the interface or function required to be called for planning the user's new task according to the text type;
[0056] S22: The task executor decomposes the text of the new task of the user according to the interface or function that is output by the task planner and is required to be called for planning the new task of the user, and forms a plurality of subtasks.
[0057] Specifically, the user's input to the LLM model can be of various types, such as natural language, code, etc. In this embodiment, the task planner can identify the text type of the user's new task, and according to the text type, output the interface or function required to plan the user's new task. It is worth mentioning that although the browser may have diversity and complexity, the extraction of long texts therein is nothing more than processing the browser DOM elements through different methods. This process is different from mathematical, symbolic or image processing problems, and requires strong reasoning ability to achieve correct task planning. Therefore, in the task decomposition planning process of this embodiment, there is no need to add reasoning thinking. It is only necessary to decompose the language input by the user to form subtasks and collect them into task planning in steps.
[0058] S3: The browser agent selects the corresponding perception function to execute each subtask in turn according to each subtask in the task list, and returns the task execution result after each subtask is executed.
[0059] Specifically, in this embodiment, given a new user task, the task planning agent decomposes the task into a series of steps that need to be executed, namely, task planning. The next step is then delegated to the browser agent for execution. The browser agent can essentially be considered as a nested chat, which is newly instantiated by the browser navigation planner each time it runs (that is, it does not contain previous steps in the chat history). The browser navigation agent has a set of predefined "primitive" or basic skills, such as a variety of DOM techniques for observing the denoised browser state and controlling the browser instance using Playwright. The browser navigation agent uses available skills to perform subtasks and returns a summary of the actions taken to perform the task, or answers the planner if the task is a question.
[0060] In some embodiments, Figure 4 As shown, the step S3 may include the following steps:
[0061] S31: The browser navigation planner identifies each subtask in the task plan and outputs the DOM method required to be called to execute each subtask;
[0062] S32: The browser navigation executor calls the DOM method to perceive or extract the browser content.
[0063] In this embodiment, the browser navigation planner supports multiple DOM synthesis techniques, enabling the browser agent to choose the method that best suits the task. If the task is to summarize the information on the page, it can simply use the GetDOM method that contains only text content. If the task is to identify and perform a search on the page, it can use the content type input field. If the task is to list all interactive elements on the page, it can use all fields. This optimizes the information provided to the agent and avoids problems associated with a noisy DOM. Another key lies in the DOM denoising technology, which preserves the parent-child relationship of elements as much as possible and is related to all fields and input fields. This is different from some other early implementations that use flat DOM coding. In addition, in order to make it easier to identify and interact with HTML elements, the browser agent of this scheme injects a custom identifier attribute into each DOM element during the perception process.
[0064] S4: The discriminator judges the rationality of the response and planning of each task execution result and the subtask corresponding to the task execution result, and optimizes the task planning and task execution process according to the judgment result.
[0065] Specifically, in this embodiment, an introspection mechanism is introduced for the task planning agent and the browser agent, that is, it can judge the rationality of task planning and execution according to the execution results of the task, and generate feedback, and optimize the task planning process and execution through feedback.
[0066] In some embodiments, see Figure 5 , this step S4 may include the following steps:
[0067] S41: training a discriminator through a training set, where the training set includes a data set with reasonableness annotated for task execution results and task planning;
[0068] S42: the discriminator obtains each execution result executed by the browser navigation executor and the subtask corresponding to each execution result, and outputs the determination result;
[0069] S43: If the determination result is positive, the corresponding execution result is directly output; if the determination result is negative, the determination result is input into the task planner to re-plan the task.
[0070] Specifically, in this embodiment, the above-mentioned introspection mechanism needs to be implemented by a discriminator, which is trained by a labeled training set. The input of the training set is the task planning and the corresponding execution result, and the output is the discrimination result. Furthermore, by inputting each subtask and the corresponding execution result to the discriminator, the rationality of each subtask execution can be output, so that it can be found from which subtask and its execution the task planning is wrong. Furthermore, for the execution result with a negative judgment result, its judgment result is input into the task planning agent as an optimization signal, and the task planning is re-performed.
[0071] In some implementations, after the above step S4, the following steps may also be included:
[0072] S5: When the browser navigation executor executes the subtasks in sequence, if the human-machine verification operation is triggered on the browser side, the task execution summary is returned to the user.
[0073] Specifically, this embodiment includes two modes: autonomous mode and human-computer collaboration mode. In the autonomous mode, the task planning agent and the browser agent perform the task end-to-end to the best of their ability, while in the human-computer collaboration mode, when the browser agent encounters an unfinished step in the process of sequentially executing subtasks (such as logging into a web page, solving a verification code triggered by a website) or when the task itself is ambiguous and needs clarification, it will return to the user.
[0074] See also Figure 6 , is a structural block diagram of an embodiment of a long text processing system based on an introspection mechanism of the present invention. The long text processing system based on an introspection mechanism of this embodiment is used to implement the long text processing method based on an introspection mechanism as described in the above embodiment. Specifically, the long text processing system based on an introspection mechanism of this embodiment includes an agent construction module 100, a task planning module 200, a subtask execution module 300 and an introspection feedback module 400. Among them:
[0075] An agent building module 100 is used to build a task planning agent and a browser agent based on a pre-trained large language model;
[0076] A task planning module 200 is used to respond to a new task from a user, wherein the task planning agent decomposes the new task from the user into a plurality of subtasks and outputs a task list;
[0077] Subtask execution module 300, used for the browser agent to select the corresponding perception function to execute each subtask in turn according to each subtask in the task list, and return the task execution result after each subtask is executed;
[0078] The introspection feedback module 400 is used to judge the rationality of the response and planning of each task execution result and the subtask corresponding to the task execution result through a discriminator, and optimize the task planning and task execution process according to the judgment result.
[0079] In some embodiments, the agent construction module 100 includes:
[0080] The task planning agent construction submodule is used to construct a task planning agent according to the pre-trained large language model, including a task planner and a task planning executor. The task planner outputs the function or interface required to complete the task planning according to the user's new task, and the task planning executor performs task planning for the user's new task by calling the function or interface.
[0081] The browser agent construction submodule is used to construct a browser agent according to the pre-trained large language model, including a browser navigation planner and a browser navigation executor. The browser navigation planner outputs the DOM method called by the browser navigation according to the task plan, and the browser navigation executor extracts the browser content according to the DOM method.
[0082] The present invention uses a browser agent to call the corresponding DOM method according to each subtask in the step-by-step planning, so as to extract the browser text; through the task planning agent and the browser agent, it can deal with web pages with complexity and variability; through the introspection feedback mechanism, it can judge and optimize the task planning; through the human-computer collaboration mode, when the human-computer verification operation is triggered, the task execution summary is returned to the user.
[0083] On the other hand, an embodiment of the present invention further provides a computer device, comprising: a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement any of the above-mentioned long text processing methods. The computer device comprises a processor, a memory, a network interface, a display screen, and an input device connected via a system bus. Among them, the processor of the computer device is used to provide computing and control capabilities. The memory of the computer device comprises a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and a computer program. The internal memory provides an environment for the operation of the operating system and the computer program in the non-volatile storage medium. The network interface of the computer device is used to communicate with an external terminal via a network connection. When the computer program is executed by the processor, a multi-agent long text processing method based on a large language model is implemented. The display screen of the computer device may be a liquid crystal display screen or an electronic ink display screen, and the input device of the computer device may be a touch layer covered on the display screen, or a key, trackball, or touchpad provided on the housing of the computer device, or an external keyboard, touchpad, or mouse, etc.
[0084] On the other hand, an embodiment of the present invention further provides a computer-readable storage medium on which a computer program is stored. When the computer program is executed by a processor, the long text processing method described in any one of the above items is implemented.
[0085] Those skilled in the art can understand that all or part of the processes in the above-mentioned embodiment methods can be completed by instructing the relevant hardware through a computer program, and the computer program can be stored in a non-volatile computer-readable storage medium. When the computer program is executed, it can include the processes of the embodiments of the above-mentioned methods. Among them, any reference to memory, storage, database or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM) or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. As an illustration and not limitation, RAM is available in many forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), double data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link (Synchlink) DRAM (SLDRAM), memory bus (Rambus) direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM).
[0086] The above content only expresses the preferred embodiments of the present invention, and its description is relatively specific and detailed, but it cannot be understood as limiting the scope of the invention patent. It should be pointed out that for ordinary technicians in this field, several modifications and improvements can be made without departing from the concept of the present invention, which all belong to the protection scope of the present invention. Therefore, the protection scope of the patent of the present invention shall be based on the attached claims.
Claims
1. A long text processing method based on introspection mechanism, characterized in that: The following steps are involved: S1: Build task planning agent and browser agent based on the pre-trained large language model; S2: In response to the user's new task, the task planning agent decomposes the user's new task into multiple subtasks and outputs a task list; S3: the browser agent selects the corresponding perception function to execute each subtask in turn according to each subtask in the task list, and returns the task execution result after each subtask is executed; S4: The discriminator judges the rationality of the response and planning of each task execution result and the subtask corresponding to the task execution result, and optimizes the task planning and task execution process according to the judgment result.
2. The long text processing method based on the introspection mechanism as claimed in claim 1, characterized in that: The step S1 comprises the following steps: S11: constructing a task planning agent according to the pre-trained large language model, including a task planner and a task planning executor, wherein the task planner outputs a function or interface required to complete the task planning according to the user's new task, and the task planning executor performs task planning for the user's new task by calling the function or interface; S12: Based on the pre-trained large language model, a browser agent is constructed, including a browser navigation planner and a browser navigation executor. The browser navigation planner outputs the DOM method called by the browser navigation according to the task plan, and the browser navigation executor extracts the browser content according to the DOM method.
3. The long text processing method based on the introspection mechanism as claimed in claim 2 is characterized in that: The step S2 comprises the following steps: S21: The task planner identifies the text type of the user's new task, and outputs the interface or function required to be called for planning the user's new task according to the text type; S22: The task executor decomposes the text of the new task of the user according to the interface or function that is output by the task planner and is required to be called for planning the new task of the user, and forms a plurality of subtasks.
4. The long text processing method based on the introspection mechanism as claimed in claim 2 is characterized in that: The step S3 comprises the following steps: S31: The browser navigation planner identifies each subtask in the task plan and outputs the DOM method required to be called to execute each subtask; S32: The browser navigation executor calls the DOM method to perceive or extract the browser content.
5. The long text processing method based on the introspection mechanism as claimed in claim 2, characterized in that: The step S4 comprises the following steps: S41: training a discriminator using a training set, where the training set includes a data set with reasonableness annotated for task execution results and task planning; S42: the discriminator obtains each execution result executed by the browser navigation executor and the subtask corresponding to each execution result, and outputs the determination result; S43: If the determination result is positive, the corresponding execution result is directly output; if the determination result is negative, the determination result is input into the task planner to re-plan the task.
6. The long text processing method based on the introspection mechanism as claimed in claim 5 is characterized in that: After step S4, the method further includes the following steps: S5: When the browser navigation executor executes the subtasks in sequence, if the human-machine verification operation is triggered on the browser side, the task execution summary is returned to the user.
7. A long text processing system based on introspection mechanism, characterized in that: include: The agent building module is used to build task planning agents and browser agents based on the pre-trained large language model; A task planning module, used for responding to a new task from a user, wherein the task planning agent decomposes the new task from the user into a plurality of subtasks and outputs a task list; A subtask execution module, used for the browser agent to select the corresponding perception function to execute each subtask in turn according to each subtask in the task list, and return the task execution result after each subtask is executed; The introspection feedback module is used to judge the rationality of the response and planning of each task execution result and the subtask corresponding to the task execution result through the discriminator, and optimize the task planning and task execution process according to the judgment results.
8. The long text processing system based on the introspection mechanism as claimed in claim 7, characterized in that: The agent building blocks include: The task planning agent construction submodule is used to construct a task planning agent according to the pre-trained large language model, including a task planner and a task planning executor. The task planner outputs the function or interface required to complete the task planning according to the user's new task, and the task planning executor performs task planning for the user's new task by calling the function or interface. The browser agent construction submodule is used to construct a browser agent according to the pre-trained large language model, including a browser navigation planner and a browser navigation executor. The browser navigation planner outputs the DOM method called by the browser navigation according to the task plan, and the browser navigation executor extracts the browser content according to the DOM method.
9. A computer device comprising: A memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the long text processing method according to any one of claims 1 to 6.
10. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by a processor, the long text processing method according to any one of claims 1 to 6 is implemented.