Business auditing method and system architecture based on large language model and dynamic DAG arrangement

Abstract

The application discloses a business auditing method and system architecture based on a large language model and a dynamic DAG arrangement, and relates to the technical field of artificial intelligence and task automation processing. The method is applied to a large language model and includes the following steps: receiving a to-be-audited file and auditing requirement data; performing semantic intention understanding and task disassembly processing on the auditing requirement data to determine atomic tasks; analyzing the dependency relationship between the atomic tasks and generating an initial DAG task graph based on the dependency relationship, wherein the initial DAG task graph includes multiple mutually dependent nodes; determining a current executable node from the initial DAG task graph; executing the current executable node, calling an auditing tool and / or model from a multi-modal tool library to perform business auditing on the to-be-audited file to obtain an auditing result, wherein in the case where the current executable node includes multiple parallel nodes, the multiple parallel nodes are executed in parallel. Through the application, the business auditing efficiency, flexibility and adaptability are effectively improved.

Description

Technical Field

[0001] This application relates to the fields of artificial intelligence and automated task processing technology, and in particular to a business auditing method and system architecture based on a large language model and dynamic DAG orchestration. Background Technology

[0002] With the development of artificial intelligence and large language model technology, intelligent agent systems have been widely used in the field of automated task processing. Especially in complex business scenarios such as document review and compliance inspection, existing technologies generally adopt a static architecture of "text parsing + rule engine". This method usually relies on rule engine or manual process to implement review rules, which is inefficient, has poor fault tolerance, and is difficult to cope with the task requirements of multi-source heterogeneous data, dynamic rule changes, and frequent scenario changes. Summary of the Invention

[0003] The embodiments of this application aim to at least partially solve one of the technical problems in the related art. Therefore, the first objective of the embodiments of this application is to propose a business auditing method and system architecture based on a large language model and dynamic DAG orchestration.

[0004] This application provides a business auditing method based on a large language model and dynamic DAG orchestration. The method is applied to a large language model and includes: receiving a document to be audited and auditing requirement data; performing semantic intent understanding and task decomposition processing on the auditing requirement data to determine atomic tasks; analyzing the dependencies between atomic tasks and generating an initial DAG task graph based on the dependencies, wherein the initial DAG task graph includes multiple interdependent nodes; determining the currently executable node from the initial DAG task graph; executing the currently executable node, calling the auditing tool corresponding to the currently executable node from a multimodal tool library and / or calling the model corresponding to the currently executable node from a model library, and performing business auditing on the document to be audited through the auditing tool and / or model to obtain the auditing result. The multimodal tool library is pre-configured with multiple auditing tools, and the model library is pre-configured with multiple models. Each node needs to use at least one auditing tool and / or at least one model during execution. If the currently executable node includes multiple parallel nodes, the multiple parallel nodes are executed in parallel.

[0005] In other embodiments, the method further includes: dynamically updating the initial DAG task graph based on the audit results, wherein dynamically updating the initial DAG task graph includes at least one of the following: adding nodes to the initial DAG task graph, modifying nodes in the initial DAG task graph, or adding a feedback loop mechanism to the initial DAG task graph, wherein the feedback loop mechanism is used to wait for newly added available audit tools or new models to conduct business audits.

[0006] In other implementations, the initial DAG task graph is dynamically updated based on the audit results, including: when the audit results indicate that the business audit has failed or the audit results do not meet expectations, audit anomaly diagnosis processing is performed to obtain a diagnosis result; based on the diagnosis result, the initial DAG task graph is dynamically updated to obtain an updated DAG task graph; and the updated DAG task graph is resumed for execution.

[0007] In other implementations, the initial DAG task graph is dynamically updated based on the diagnostic results, including at least one of the following: If the diagnostic results indicate that the data quality of the document to be reviewed is lower than a preset quality, a new node is added to the initial DAG task graph, wherein the new node corresponds to a new review tool and / or a new model; if the diagnostic results indicate that the review tool or model corresponding to a node in the initial DAG task graph has review quality issues, the node is modified, wherein modifying the node includes replacing the review tool or model corresponding to the node, or modifying the parameters of the review tool or model corresponding to the node; if the diagnostic results indicate that the review tool or model corresponding to a node in the initial DAG task graph has failed the review, a feedback loop mechanism is added to the initial DAG task graph, and the process waits for the addition of a new available review tool or model based on the feedback loop mechanism; if the diagnostic results indicate that the document to be reviewed lacks information, a manual review node is added to the initial DAG task graph.

[0008] In other implementations, before generating the initial DAG task graph, the method further includes: determining whether a historical DAG task graph matching the audit requirement data is stored; if so, obtaining the historical DAG task graph as the initial DAG task graph.

[0009] In other embodiments, the method further includes: generating corresponding task code based on atomic tasks, and storing the task code in association with the initial DAG task graph so that the task code can be invoked when the initial DAG task graph is executed; wherein, executing the current executable node and invoking the corresponding audit tool from the multimodal tool library and / or invoking the corresponding model from the model library includes: invoking and running the task code corresponding to the atomic task when executing the atomic task corresponding to the current executable node; and invoking the corresponding audit tool from the multimodal tool library and / or invoking the corresponding model from the model library during the execution of the task code.

[0010] In other implementations, executing the current executable node includes: determining the predecessor node of the current executable node and obtaining the cached calculation result of the predecessor node; replacing the placeholder of the current executable node with the cached calculation result and executing the current executable node so as to perform business review on the document to be reviewed based on the cached calculation result.

[0011] In other implementations, the audit results include multiple sub-results corresponding to multiple nodes in the DAG task graph; the method further includes: encapsulating audit tools in a multimodal tool library through a standardized protocol interface; and / or performing unified semantic aggregation processing on the multiple sub-results to obtain an audit aggregation result and output it.

[0012] This application provides a business review system architecture based on a large language model and dynamic DAG orchestration. The system architecture includes: an application layer configured to provide a business review interface so that users can input and receive files to be reviewed and review requirement data through the business review interface; an access layer configured to at least receive files to be reviewed and review requirement data; a tool layer configured to provide a multimodal tool library; a model layer configured to provide a model library; and a functional layer configured to at least perform semantic intent understanding and task decomposition processing on the review requirement data to determine atomic tasks; analyze the dependencies between atomic tasks, and generate an initial DAG task graph based on the dependencies, wherein the initial DAG task graph includes multiple interdependent nodes; from the initial... The current executable node is determined in the initial DAG task graph. Based on the current executable node, the corresponding audit tool is called from the multimodal tool library and / or the corresponding model is called from the model library. The audit tool and / or model are used to perform business audit on the document to be audited in order to obtain the audit result. The multimodal tool library is pre-configured with multiple audit tools and the model library is pre-configured with multiple models. Each node needs to use at least one audit tool and / or at least one model when it is executed. If the current executable node includes multiple parallel nodes, the multiple parallel nodes are executed in parallel. The resource layer is configured to store at least the DAG task graph, the cached calculation results of each node, and the audit result.

[0013] This application provides an electronic device, including a memory and a processor. The memory stores a computer program, and the processor executes the computer program to implement the steps of the method described in any of the above embodiments.

[0014] This application provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of the method of any of the above embodiments. Attached Figure Description

[0015] Figure 1 A flowchart illustrating a business review method based on a large language model and dynamic DAG orchestration, provided for the implementation of this application.

[0016] Figure 2 A schematic diagram of a business audit system architecture based on a large language model and dynamic DAG orchestration provided for the implementation of this application.

[0017] Figure 3A business review flowchart provided for the implementation of this application.

[0018] Figure 4 This application provides an example of business auditing based on a large language model and dynamic DAG orchestration for implementing this application.

[0019] Figure 5 A schematic diagram of a business review device based on a large language model and dynamic DAG orchestration provided for an embodiment of this application.

[0020] Figure 6 A block diagram of an electronic device provided in an embodiment of this application. Detailed Implementation

[0021] The embodiments of this application are described in detail below. Examples of the embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and intended to explain this application, and should not be construed as limiting this application.

[0022] With the development of artificial intelligence and large language model technology, intelligent agent systems have been widely used in the field of automated task processing. Especially in complex business scenarios such as document review and compliance inspection, existing technologies generally adopt a static architecture of "text parsing + rule engine". This method usually relies on rule engine or manual process to implement review rules, which is inefficient, has poor fault tolerance, and is difficult to cope with the task requirements of multi-source heterogeneous data, dynamic rule changes, and frequent scenario changes.

[0023] The technical process of some business review systems includes: data collection → text parsing → information extraction → rule matching → result output. This architecture heavily relies on manual coding to implement review rules. Each new or adjusted business rule requires the intervention of professional developers for code writing and debugging. As business complexity continues to rise and review requirements become increasingly diverse, the system's dependence on development resources has significantly intensified. This method not only leads to long iteration cycles and slow response times, but also further restricts review efficiency and business agility due to misunderstandings and communication costs between business personnel and the development team.

[0024] Specifically, some technologies have the following main drawbacks:

[0025] 1. Poor fault tolerance: Some technologies employ linear or static directed acyclic graph (DAG) processes. If any step (such as optical character recognition (OCR)) fails, the entire task terminates with an error. For example, in the review of cross-border transaction documents, if invoice OCR recognition fails, the system cannot continue to execute other parallel tasks, leading to a prolonged review period. OCR technology has a high failure rate in complex scenarios (such as blurry images or non-standard formats) and lacks an automatic repair mechanism.

[0026] 2. Low Development Efficiency: Low development efficiency is mainly reflected in the high coupling between rule configuration and code. Every change in business logic requires developers to manually adjust the underlying code, resulting in long testing and regression cycles and slow deployment response. Non-technical personnel cannot operate independently, leading to a severe backlog of requirements.

[0027] In view of this, this application proposes a business review method and system architecture based on a large language model and dynamic DAG orchestration. It utilizes a large language model to understand the semantic intent of the review materials, dynamically generates a DAG task graph, executes review tasks based on this graph, and supports parallel execution of multiple nodes, effectively improving the efficiency, flexibility, and adaptability of business review.

[0028] Figure 1 A flowchart illustrating a business review method based on a large language model and dynamic DAG orchestration, provided for the implementation of this application.

[0029] like Figure 1 As shown, the business auditing method based on a large language model and dynamic DAG orchestration provided in this application is applied to a large language model and includes steps S110-S150.

[0030] Step S110: Receive the documents to be reviewed and the review requirements data.

[0031] For example, the review documents may include business-related documents or materials uploaded by users, such as business contracts, merchant business licenses, financial documents, etc. The review requirement data may include user review requirements associated with the review documents, i.e. the review tasks to be performed. For example, it may receive merchant business licenses uploaded by users as review documents, and receive corresponding review requirement data uploaded by users, such as "I need to determine the legality of the business license" and related specific requirement data.

[0032] Step S120: Perform semantic intent understanding and task decomposition processing on the audit requirement data to determine the atomic tasks.

[0033] For example, a Large Language Model (LLM) can be used to perform semantic intent understanding analysis and task decomposition on the audit requirement data, i.e., the complex audit tasks that need to be performed, to obtain multiple atomic tasks. Each atomic task is independent and executable. For example, for the received merchant business license document (audit document) and the related audit requirements for judging the legality of the business license, one executable atomic task can be decomposed into file format verification, i.e., judging whether the audit document input is an image. The image format can be Joint Photographic Experts Group (JPEG) format, which is also known as JPG format. The image format can also be Portable Network Graphics (PNG).

[0034] Step S130: Analyze the dependencies between atomic tasks and generate an initial DAG task graph based on the dependencies. The initial DAG task graph includes multiple interdependent nodes.

[0035] For example, the dependencies between atomic tasks can be the user's review requirements (review requirement data), the execution order of several atomic tasks, that is, determining which tasks must be completed before other tasks. For example, the "file format verification" task must be executed first to confirm that the review file is a valid input file before other task nodes can continue to be executed. Based on this arrangement, an initial DAG task graph is generated, which includes multiple interdependent nodes, representing the execution order of atomic tasks.

[0036] Step S140: Determine the currently executable node from the initial DAG task graph.

[0037] For example, nodes without prerequisites or whose prerequisite tasks have been completed can be found in the initial DAG task graph, which are executable nodes. For instance, during initial execution, the current executable node is the node of the "file format verification" task.

[0038] Step S150: Execute the current executable node, call the audit tool corresponding to the current executable node from the multimodal tool library and / or call the model corresponding to the current executable node from the model library, and perform business audit on the document to be audited through the audit tool and / or model to obtain the audit result. The multimodal tool library is pre-configured with multiple audit tools, and the model library is pre-configured with multiple models. Each node needs to use at least one audit tool and / or at least one model when it is executed. If it is determined that the current executable node includes multiple parallel nodes, the multiple parallel nodes are executed in parallel.

[0039] For example, the task of the current executable node can be executed by calling the audit tool / model. That is, for each current executable node, the corresponding audit tool (such as a file parsing tool, a graph parsing tool, etc.) is called from the tool layer of the multimodal tool library or the corresponding model (such as an LLM model, an LMM model, etc.) is called from the model layer of the model library for execution. When the task is successfully executed, the audit result of the current node is obtained, and then the next executable node is executed to obtain the final audit result. Furthermore, if it is determined that the current executable node includes multiple parallel nodes, that is, the current multiple nodes do not have a sequential dependency, then the multiple parallel nodes are executed in parallel.

[0040] The multimodal tool library can be a tool library with multiple pre-configured review tools, and the model library can be a model library with multiple pre-configured models. See below for details. Figure 2 The description of the functional layer-related parts states that each node requires the use of at least one audit tool and / or at least one model during execution.

[0041] In the technical solution of this application embodiment, the document to be reviewed and the review requirement data are first received. Then, the review requirement data is processed by semantic intent understanding and task decomposition to determine atomic tasks. Next, the dependencies between atomic tasks are analyzed, and an initial DAG task graph is generated based on the dependencies. Then, the current executable node is determined from the initial DAG task graph. Finally, the current executable node is executed. The review tool corresponding to the current executable node is called from the multimodal tool library and / or the model corresponding to the current executable node is called from the model library. The review tool and / or model are used to conduct business review of the document to be reviewed in order to obtain the review result. The semantic intent of the review material is understood by using a large language model, and the initial DAG task graph is dynamically generated. Based on this, the review task is executed and multi-node parallel execution is supported, which effectively improves the efficiency, flexibility and adaptability of business review.

[0042] In one example, the business review method based on large language model and dynamic DAG orchestration of this application is executed through a business review system architecture based on large language model and dynamic DAG orchestration. This system analyzes and decomposes review documents based on LLM (Large Language Model), dynamically generating a task flow in the form of an initial DAG task graph for efficient and automated task review. The following describes the process in conjunction with... Figure 2 The functions of each part of the system architecture are described in detail.

[0043] Figure 2 A schematic diagram of a business audit system architecture based on a large language model and dynamic DAG orchestration provided for the implementation of this application.

[0044] like Figure 2As shown, the business audit system architecture based on large language models and dynamic DAG orchestration includes an application layer, an access layer, a functional layer, a model layer, and a resource layer.

[0045] (1) Application layer: This is the top layer of the system, which is oriented towards end users or business systems. It provides specific business function interfaces and directly serves specific business processes, such as contract review, merchant business license review, and financial review.

[0046] (2) Access Layer: As a bridge between the application layer and the underlying system, it is responsible for receiving external input and standardizing its processing. Its role is to unify the entry point and decouple business from internal implementation. Key input items include: file path, the path to the file to be reviewed; review rules, specifying the review logic or strategy; file description (optional), auxiliary information to help understand the file background; other descriptions (optional), additional context or parameters.

[0047] (3) Functional layer: It contains the core processing logic and is divided into three major modules: planning, execution, and memory, as well as an independent tool layer and MCP (Model Context Protocol, a protocol for large models to interact with external tools).

[0048] Planning module: Used for parallel task analysis, task planning, reflection and correction (supports iterative optimization).

[0049] Execution module: used for DAG task graph repair (directed acyclic graph repair to ensure correct task flow), DAG task graph execution (running tasks according to dependencies), and DAG task graph recall (retracing historical task flow).

[0050] Memory module: Used for storing DAG task graphs (saving task execution process) and recalling DAG task graphs (for reproduction or debugging).

[0051] Through a closed-loop mechanism of "planning → execution → memory", intelligent task scheduling and continuous learning are achieved.

[0052] Tool Layer: This layer includes various auditing tools, such as document parsing, image parsing, business registration interface (API), and rule engine. Document parsing: used to extract structured data; Image parsing: used for image content recognition; Business Registration Interface (API): used to call external business registration systems to obtain enterprise information; Rule Engine: executes preset auditing rules.

[0053] MCP: Used to interface with various MCP servers, including external platforms such as PaddlePaddle. PaddlePaddle provides the intelligent document parsing and text recognition tool PaddleOCR. The MCP server provides the AI ​​Model Context Protocol (MCP), which standardizes the AI ​​tool invocation process. Paddle refers to PaddlePaddle, an open-source deep learning platform that provides a rich set of tools and libraries supporting various AI tasks. PaddleOCR is an optical character recognition (OCR) tool based on PaddlePaddle.

[0054] (4) Model layer: This layer provides a model library to execute nodes in the DAG task graph by calling the corresponding models. Examples include LLM models, Large Marketing Model (LMM), ComputerVision (CV) models, and EM&Rerank models. EM&Rerank is a semantic retrieval model that includes EM (Exact Match) and Rerank.

[0055] (5) Resource layer: including CPU (e.g. x86 architecture, ARM processor architecture), AI accelerator card (e.g. NVIDIA, Ascend), operating system (e.g. Linux, Kylin) and storage module, used to store various data in the business review process of the system, such as DAG task graph, cached calculation results of each node, and review results; among which, the storage module includes various storage databases, such as Redis (remote dictionary service), MySQL (relational database management system), MinlO (object storage server), and milvus (vector database).

[0056] Next, combined Figure 3 This paper provides a detailed explanation of the business review process using a business review system architecture based on a large language model and dynamic DAG orchestration.

[0057] Figure 3 A business review flowchart provided for the implementation of this application.

[0058] like Figure 3 As shown, the business review system architecture based on a large language model and dynamic DAG orchestration includes three stages: DAG task graph construction and parsing, DAG task graph execution and monitoring, and DAG task graph self-healing. Specifically, it includes the following steps:

[0059] Step 301: The task begins by receiving complex audit requests (including documents to be audited and audit requirement data) from the user.

[0060] Step 302: Use an LLM planner to analyze task dependencies and break them down into atomic tasks. The planner can be generated based on a large language model (LLM).

[0061] Step 303: The code agent generates Python (a programming language) code based on the atomic task description to implement the atomic task. The code agent can also be generated based on a large language model (LLM), or generated using other methods and integrated into a large language model (LLM).

[0062] Step 304: Generate the initial DAG task graph based on the dependencies.

[0063] Step 305: Store the initial DAG task graph into the memory module.

[0064] Step 306: The executor executes the scheduling process, reads the DAG task graph from the memory module, and prepares to execute the task. The executor can also be generated based on a large language model (LLM).

[0065] Step 307: Extract the currently executable nodes. For example, find all nodes in the DAG task graph that have no prerequisites or whose prerequisite tasks have been completed as the currently executable nodes.

[0066] Step 308: Invoke the tool / model for execution. For each currently executable node in the DAG task graph, invoke the corresponding tool or model to execute the currently executable node (such as image processing, text generation, etc.).

[0067] Step 309: Execution result check. Check whether the task execution result is successful. If it fails or the confidence level is low, proceed to step 312. If it succeeds, proceed to step 310.

[0068] Step 310: Determine whether the entire DAG task graph has been fully executed; if yes, proceed to step 311; otherwise, proceed to step 307.

[0069] Step 311: Result Aggregation and Output. The output sub-results of all nodes' corresponding tasks undergo unified semantic aggregation processing, and are integrated into a final audit aggregation result, which is then returned to the user.

[0070] Step 312, trigger an exception event.

[0071] Step 313, LLM (Large Language Model) Cause Diagnosis. Use the Large Language Model to analyze the reasons for failure.

[0072] Step 314: Dynamically update the initial DAG task graph, such as inserting image enhancement nodes, switching to a larger model type and retrying, suspending and requesting manual intervention, and continue to step 307.

[0073] The following provides a detailed explanation of the three stages of business review.

[0074] For example, before generating the initial DAG task graph, the DAG task graph is recalled based on the received user review request data. For example, it is determined whether a historical DAG task graph matching the review request data is stored; if so, the historical DAG task graph is obtained as the initial DAG task graph.

[0075] Specifically, when receiving new review request data input by the user, the system architecture's memory module recalls the DAG task graph to check if there is a stored review process with high similarity that has been resolved in the past (a matching historical DAG task graph). If so, the historical DAG task graph is retrieved and reused; otherwise, a new initial DAG task graph is created directly to resolve the review request, and the initial DAG task graph is stored.

[0076] In the technical solution of this application embodiment, before generating the initial DAG task graph, it is determined whether a historical DAG task graph matching the audit requirement data is stored. If so, the historical DAG task graph is obtained as the initial DAG task graph. The caching mechanism eliminates the need for repeated planning in the production environment, and the planning results can be reused, which greatly shortens the response time, improves system performance, and solves the problem of resource waste in the existing preset audit process.

[0077] For example, an initial DAG task graph and corresponding implementation code are generated based on the received audit requirement data. For instance, based on atomic tasks, corresponding task code is generated, and the task code is associated with and stored in the initial DAG task graph so that the task code can be called when the initial DAG task graph is executed.

[0078] Specifically, an executable DAG task graph is constructed based on the user-input task request (review requirement data), including the following process:

[0079] Task Start: The process begins, receiving user input regarding the review request.

[0080] Task decomposition: The task is analyzed and planned using a Large Language Model (LLM) to generate preliminary execution logic.

[0081] Analyze task dependencies: Analyze the dependencies between tasks to determine which tasks must be completed before other tasks.

[0082] The code agent implements atomic tasks: The code agent automatically generates Python code (task code, or other programming code based on the actual programming language) based on the atomic task description, and completes the verification.

[0083] Generate DAG task graph: Break down complex tasks into several independent, executable "atomic tasks", construct an initial DAG task graph based on dependencies, and represent the execution order of tasks.

[0084] Store in memory module: Store the generated initial DAG task graph in the system architecture's memory module, and store the associated Python code in the code repository for later execution.

[0085] In the technical solution of this application embodiment, an initial DAG task graph is generated based on the received review requirement data. Based on atomic tasks, corresponding task codes are generated and the task codes are associated with and stored in the initial DAG task graph so that the task codes can be called when the initial DAG task graph is executed. Parallel subtasks are automatically split through task dependency analysis, which significantly improves the review throughput. It is especially suitable for scenarios with multiple documents and multiple rules. The dependency relationship of tasks is explicitly modeled using DAG task graph, making the process clear, traceable, and easy to debug, effectively improving the flexibility of business review.

[0086] For example, the current executable node is executed to perform business audit on the document to be audited. For instance, firstly, based on the current executable node, the corresponding audit tool is called from the multimodal tool library and / or the corresponding model is called from the model library; then, the document to be audited is performed through the audit tool and / or model.

[0087] Specifically, the tasks corresponding to the nodes in the DAG task graph are executed, and their status is monitored in real time, including the following process:

[0088] Executor scheduling: The scheduler reads the DAG task graph from the memory module and prepares to execute tasks.

[0089] Extract currently executable nodes: Find all nodes in the DAG task graph that have no prerequisites or whose prerequisite tasks have been completed (i.e., "currently executable nodes").

[0090] Tool / Model Invocation: For each currently executable node, the corresponding audit tool is invoked from the system architecture's tool layer. These audit tools include, but are not limited to, file parsing tools, graph parsing tools, business interface APIs, and rule engines. Alternatively, the corresponding model is invoked from the system architecture's model layer for execution. These models include, but are not limited to, LLM, LMM, CV, EM & Rerank. See above for details. Figure 2 Description of the relevant sections.

[0091] Then, the audit tools or models are used to conduct business audits on the documents to be audited. When the audit tools or models are executed, the previously stored Python task code can be called, and the corresponding task can be executed based on the mapping relationship between the task code and the nodes in the DAG task graph.

[0092] In the technical solution of the embodiment of the present application, first, based on the current executable node, the corresponding audit tool is called from the multimodal tool library and / or the corresponding model is called from the model library, and then the business audit of the file to be audited is performed through the audit tool and / or the model. By calling the multimodal tool for business audit, the flexibility and robustness of the audit process are improved, and accurate and efficient automated audit is achieved.

[0093] Exemplarily, executing the current executable node and calling the corresponding audit tool from the multimodal tool library and / or the corresponding model from the model library includes: when executing the atomic task corresponding to the current executable node, calling and running the task code corresponding to the atomic task; during the process of running the task code, calling the corresponding audit tool from the multimodal tool library and / or the corresponding model from the model library.

[0094] Exemplarily, executing the current executable node to perform a business audit on the file to be audited. For example, first, determine the previous node of the current executable node and obtain the cached calculation result of the previous node; then, replace the placeholder of the current executable node with the cached calculation result and execute the current executable node to perform a business audit on the file to be audited based on the cached calculation result.

[0095] Specifically, during the process of performing the audit according to the DAG task graph, data transfer between nodes is achieved through placeholder replacement, and repeated tool calls are avoided by combining temporary caching. For example, in the planning stage, the current executable node T5 and the previous node T2 are determined. The T2 node has been successfully executed and the corresponding cached calculation result has been obtained. For example, the T2 node obtains the OCR result (cached calculation result) by calling the OCR engine (an audit tool), and gets {"name": "XX Technology Co., Ltd.", "type": "Limited Liability Company"...}. Then, when executing the T5 node, the placeholder <ocr_data.name field> is automatically replaced with the actual string "XX Technology Co., Ltd.", and then the name verification function is called to perform a business audit on the file to be audited.

[0096] In the technical solution of the embodiment of the present application, first, determine the previous node of the current executable node and obtain the cached calculation result of the previous node, then replace the placeholder of the current executable node with the cached calculation result, and execute the current executable node to perform a business audit on the file to be audited based on the cached calculation result, effectively improving the audit efficiency.

[0097] Exemplarily, the audit result includes multiple sub-results corresponding to multiple nodes in the DAG task graph; in the case where the DAG task graph has been fully executed, the audit results are aggregated. For example, unified semantic aggregation processing is performed on the multiple sub-results to obtain the audit aggregation result and output it.

[0098] For example, the initial DAG task graph can also be dynamically updated based on the audit results. The dynamic update of the initial DAG task graph includes at least one of the following: adding nodes to the initial DAG task graph, modifying nodes in the initial DAG task graph, or adding a feedback loop mechanism to the initial DAG task graph. The feedback loop mechanism is used to wait for newly available audit tools or new models to conduct business audits.

[0099] For example, when the audit result does not meet expectations or a task fails to be executed, the DAG task graph self-healing is performed. For example, the initial DAG task graph is dynamically updated based on the audit result, including: when the audit result indicates that the business audit has failed or the audit result does not meet expectations, audit anomaly diagnosis processing is performed to obtain the diagnosis result; then, based on the diagnosis result, the initial DAG task graph is dynamically updated to obtain the updated DAG task graph; finally, the updated DAG task graph is resumed to be executed.

[0100] For example, based on the diagnostic results, the initial DAG task graph is dynamically updated, including at least one of the following: if the diagnostic results indicate that the data quality of the document to be reviewed is lower than the preset quality, a new node is added to the initial DAG task graph, wherein the new node corresponds to a new review tool and / or a new model; if the diagnostic results indicate that the review tool or model corresponding to a node in the initial DAG task graph has review quality issues, the node is modified, wherein modifying the node includes replacing the review tool or model corresponding to the node, or modifying the parameters of the review tool or model corresponding to the node; if the diagnostic results indicate that the review tool or model corresponding to a node in the initial DAG task graph fails to review, a feedback loop mechanism is added to the initial DAG task graph, and the feedback loop mechanism is used to wait for the addition of a new available review tool or a new model; if the diagnostic results indicate that the document to be reviewed lacks information, a manual review node is added to the initial DAG task graph.

[0101] Specifically, upon completion of each node, a result check is performed. If a sub-result or audit result fails to meet the conditions or the task execution fails, the DAG task graph self-healing (reasoning and correction) is performed, which includes the following process:

[0102] Execution Result Check: Checks whether the task execution was successful. If it fails or does not meet the conditions, the DAG task graph is repaired; if successful, it continues to execute the next executable node and checks whether the entire DAG task graph has been completed. This continues until all executable nodes are completed, at which point the DAG task graph in the memory module is updated, and the outputs of all tasks are integrated into the final result (audit aggregated result), which is returned to the user. Audit aggregated result could be, for example, a combination of temporary cached results for each node.

[0103] When a task fails or the audit result does not meet expectations, the system will trigger an agent to reason and make corrections:

[0104] Triggering abnormal events: When a task fails to execute or the result does not meet expectations, the exception handling process is triggered.

[0105] LLM cause diagnosis: Use large language models to analyze the reasons for failure and determine whether it is due to data problems, model errors, or logical errors (i.e., diagnostic results).

[0106] Dynamically update the DAG task graph: Based on the diagnostic results, the agent can dynamically adjust the DAG task graph, such as adding new nodes, inserting new processing steps (such as data augmentation); modifying existing nodes, replacing models or adjusting parameters; adding feedback loops, and introducing iterative optimization mechanisms (such as manually adding new available APIs).

[0107] Specifically, the repair strategies include, but are not limited to: when the image is blurry (i.e., the data quality of the file to be reviewed is lower than the preset quality), insert an image enhancement node to preprocess the low-quality image; when the model illusion is abnormal (i.e., the review tool or model corresponding to the node has review quality issues), switch to a larger model type and retry to replace it with a more reliable model and re-execute; when the diagnostic results indicate that the review tool or model corresponding to the node in the initial DAG task graph has failed, introduce an iterative optimization mechanism (feedback loop mechanism), for example, when both the local OCR tool and the external tool that meets the MCP protocol (such as the Paddle OCR MCP tool) fail, the process is suspended and awaits manual confirmation and repair, and can continue the subsequent process (adding an available review tool or model) after the new available API is filled in manually; when the information is missing, suspend and request manual intervention, that is, when the system cannot solve it automatically, request manual intervention (add a manual review node).

[0108] Then, the execution node task is resumed, and the updated DAG task graph re-enters the "executor scheduling" process to continue executing tasks until the audit aggregation result is output.

[0109] In the technical solution of this application embodiment, multiple sub-results are subjected to unified semantic aggregation processing to obtain and output the audit aggregation result. In the event of business audit failure or audit result not meeting expectations, audit anomaly diagnosis processing is performed to obtain a diagnostic result. Then, based on the diagnostic result, the initial DAG task graph is dynamically updated to obtain an updated DAG task graph. Finally, the updated DAG task graph is restored for execution. This allows for real-time detection of node anomalies during runtime and multi-source cross-verification in collaboration with external verification tools. Through DAG task graph repair, cache reuse, condition judgment, and result verification, multiple guarantees ensure execution stability. This ensures high robustness of the audit process while achieving accurate and efficient automated auditing. At the same time, LLM (Large Language Model) runs through the entire process of rule parsing, task decomposition, scheduling decision, and result generation, achieving a high degree of automation and semantic understanding capabilities.

[0110] For example, when conducting business audits based on this system architecture, the audit tools use standardized calls, such as encapsulating audit tools from a multimodal tool library through standardized protocol interfaces.

[0111] Specifically, the system architecture adopts a unified tool calling framework based on the MCP protocol, which encapsulates the auditing tools in the multimodal tool library to achieve standardized access or calling of multimodal tools (such as file parsing, natural language processing (NLP), image recognition and other related tools) to perform corresponding auditing tasks.

[0112] In the technical solution of this application embodiment, the auditing tools in the multimodal tool library are encapsulated through a standardized protocol interface, which supports plug-and-play use of heterogeneous tools, reduces integration complexity, and improves system scalability.

[0113] Figure 4 This application provides an example of business auditing based on a large language model and dynamic DAG orchestration for implementing this application.

[0114] like Figure 4 As shown, based on the specific user review requirements and the corresponding test files (review files), business review is conducted, including the following steps:

[0115] Phase 1: Construction and Analysis of the DAG Task Graph

[0116] Step 1: The task begins. The user uploads a test file and their review request, which is "I need to verify the legality of the business license," as detailed below:

[0117] The "Type" field is set to Limited Liability Company / Joint-Stock Company;

[0118] The "Name" field does not contain words such as "individual" or "person";

[0119] The second digit of the Unified Social Credit Code represents the type of organization: 1 for the industry and commerce department, and 2 for individual businesses.

[0120] Business term: The time must be within the validity period (judgment of the reasonableness of the time);

[0121] Is the input field: a scanned copy of the business license (PDF or image)?

[0122] Business license fields include: registration number, name, type, address, legal representative, registered capital, establishment date, business term, and business scope.

[0123] Step 2: Based on the LLM (Large Language Model) planner, perform task decomposition (atomic task generation). After the LLM analyzes and reviews the requirements, it automatically breaks down the executable atomic tasks as shown in the table below:

[0124]

[0125] Step 3: Dependency Analysis

[0126] T1 → All subsequent tasks (i.e., the input file must be verified as valid first); T2 → T3~T7 (OCR must be called to extract text first); T3 → T4~T7 (i.e., validation fails if fields are missing); T4~T7 have no dependencies and can be executed in parallel. See the documentation for specific dependency relationships. Figure 4 .

[0127] Step 4: Implement the above atomic tasks sequentially through the code agent to generate Python code to solve the corresponding tasks.

[0128] Step 5: Store in memory module

[0129] The generated DAG task graph (including task definition, dependencies, and verification rules) is stored in the system memory module for execution, and the Python code is stored in association.

[0130] Phase Two: DAG Task Graph Execution and Monitoring

[0131] Step 1: Executor scheduling loads the stored DAG task graph from the memory module and begins execution.

[0132] Step 2: Extract the currently executable node. In the initial stage, only node T1 is executable (with no prerequisites).

[0133] Step 3: Execute layer by layer, as follows:

[0134] T1 execution: If the input is detected to be a JPG image, and the task passes, then T2 is executed.

[0135] T2 execution: If the OCR engine tool is invoked and returns a structured JSON (JavaScript Object Notation, a lightweight data interchange format) field, then T3 will be executed.

[0136] T3 execution: Check if the JSON field contains all 9 fields. If the task passes, proceed to the next node.

[0137] T4~T7 are executed in parallel:

[0138] T4: "Type": "Limited Liability Company" → Approved.

[0139] T5: "Name": "Beijing XX Technology Co., Ltd." → Excluding "Individual" → Approved.

[0140] T6: Unified code "91110108MA01ABCD2X" → The second digit is '1' → Approved.

[0141] T7: Business term "2020-01-01 to 2030-12-31", current time 2025-12-19 → Approved.

[0142] Step 4: If all tasks are successful, the system will proceed to result aggregation and generate the audit results (audit aggregation results), as follows:

[0143] {

[0144] "result": "Passed"

[0145] "details" {

[0146] "file_valid": true,

[0147] "ocr_success": true,

[0148] "fields_complete": true,

[0149] "type_valid": true,

[0150] "name_valid": true,

[0151] "credit_code_valid": true,

[0152] "term_valid": true

[0153] }

[0154] }

[0155] The system returns the following message to the user: "Business license is valid, approval approved."

[0156] Phase 3: DAG task graph self-healing (executed when a node task fails or the audit result does not meet expectations)

[0157] Step 1: For example, when the T2 node task fails, i.e. OCR recognition fails, the diagnosis result is that the image is blurred, rotated, or low resolution. Then, the self-healing process is triggered: Abnormal trigger T2: Returns empty, or confidence < threshold.

[0158] Step 2: LLM cause diagnosis: Analyze the logs and find "Poor image quality, OCR cannot recognize key fields".

[0159] Step 3: Dynamically update the DAG task graph: Insert a new node T1.5 between T1 and T2, and call image preprocessing tools (such as denoising, sharpening, rotation correction) for image enhancement; or if multiple enhancements still fail, insert a manual review node.

[0160] Step 4: Resume execution of the updated DAG task graph: that is, execute according to the dependency relationship of "T1→T1.5 (image enhancement)→T2→...". If the enhanced OCR recognition is successful, continue; otherwise, switch to manual execution.

[0161] It should be noted that when the T2 node is executed for the first time, the system architecture uses the file hash value (call parameter) or file path as the key to call the OCR engine to obtain the recognition result ocr_data, and stores the returned recognition result ocr_data in the cache. After inserting a new node T1.5, when the OCR engine is called again, the call parameters have not changed (i.e., the file content has been enhanced by the T1.5 node, but the file representation may not have changed, or the system uses the enhanced new file parameters). The system may directly return the previously cached recognition result ocr_data (if the system policy allows it), or update the new OCR result to the temporary cache result to ensure that subsequent nodes obtain the latest result. When subsequent executable nodes are executed, the result is also read directly from the cache, avoiding repeated calls to the OCR engine, thereby completing all review tasks.

[0162] This application provides a business review system architecture based on a large language model and dynamic DAG orchestration. The system architecture includes: an application layer configured to provide a business review interface so that users can input and receive files to be reviewed and review requirement data through the business review interface; an access layer configured to receive at least files to be reviewed and review requirement data; a tool layer configured to provide a multimodal tool library; a model layer configured to provide a model library; a functional layer configured to perform semantic intent understanding and task decomposition processing on the review requirement data to determine atomic tasks; analyze the dependencies between atomic tasks and generate an initial DAG task graph based on the dependencies, wherein the initial DAG task graph includes multiple interdependent nodes; determine the currently executable node from the initial DAG task graph; based on the currently executable node, call the corresponding review tool from the tool library and / or call the corresponding model from the model library; perform business review on the files to be reviewed through the review tool and / or model to obtain the review result, wherein, if the currently executable node includes multiple parallel nodes, multiple parallel nodes are executed in parallel; and a resource layer configured to store at least the DAG task graph, the cached calculation results of each node, and the review result.

[0163] By using a business review system architecture based on a large language model and dynamic DAG orchestration, the system can understand the semantic intent of the review materials using the large language model, dynamically generate a DAG task graph, execute review tasks based on this graph, and support parallel execution of multiple nodes, effectively improving the efficiency, flexibility, and adaptability of business review.

[0164] Figure 5 A schematic diagram of a business review device based on a large language model and dynamic DAG orchestration provided for an embodiment of this application.

[0165] This application provides a business review device 500 based on a large language model and dynamic DAG arrangement, applied to a large language model. The business review device 500 based on a large language model and dynamic DAG arrangement includes:

[0166] The receiving module 510 is used to receive documents to be reviewed and review requirement data.

[0167] Processing module 520 is used to perform semantic intent understanding and task decomposition processing on the audit requirement data to determine the atomic tasks.

[0168] The generation module 530 is used to analyze the dependencies between atomic tasks and generate an initial DAG task graph based on the dependencies. The initial DAG task graph includes multiple interdependent nodes.

[0169] The determination module 540 is used to determine the currently executable node from the initial DAG task graph.

[0170] The execution module 550 is used to execute the current executable node, call the audit tool corresponding to the current executable node from the multimodal tool library and / or call the model corresponding to the current executable node from the model library, and perform business audit on the document to be audited through the audit tool and / or model to obtain the audit result. The multimodal tool library is pre-configured with multiple audit tools, and the model library is pre-configured with multiple models. Each node needs to use at least one audit tool and / or at least one model when it is executed. If it is determined that the current executable node includes multiple parallel nodes, the multiple parallel nodes are executed in parallel.

[0171] In other embodiments, the business review device 500 based on a large language model and dynamic DAG orchestration further includes an update module for dynamically updating the initial DAG task graph based on the review results. The dynamic update of the initial DAG task graph includes at least one of the following: adding nodes to the initial DAG task graph, modifying nodes in the initial DAG task graph, or adding a feedback loop mechanism to the initial DAG task graph. The feedback loop mechanism is used to wait for new available review tools or new models to be added for business review.

[0172] In other implementations, the update module is also used to: perform audit anomaly diagnosis processing to obtain a diagnosis result when the audit result indicates that the business audit has failed or the audit result does not meet the expected result; dynamically update the initial DAG task graph based on the diagnosis result to obtain an updated DAG task graph; and resume execution of the updated DAG task graph.

[0173] In other implementations, the initial DAG task graph is dynamically updated based on the diagnostic results, including at least one of the following: If the diagnostic results indicate that the data quality of the document to be reviewed is lower than a preset quality, a new node is added to the initial DAG task graph, wherein the new node corresponds to a new review tool and / or a new model; if the diagnostic results indicate that the review tool or model corresponding to a node in the initial DAG task graph has review quality issues, the node is modified, wherein modifying the node includes replacing the review tool or model corresponding to the node, or modifying the parameters of the review tool or model corresponding to the node; if the diagnostic results indicate that the review tool or model corresponding to a node in the initial DAG task graph has failed the review, a feedback loop mechanism is added to the initial DAG task graph, and the process waits for the addition of a new available review tool or model based on the feedback loop mechanism; if the diagnostic results indicate that the document to be reviewed lacks information, a manual review node is added to the initial DAG task graph.

[0174] In some other implementations, before generating the initial DAG task graph, the business review device 500 based on a large language model and dynamic DAG orchestration further includes an acquisition module for: determining whether a historical DAG task graph matching the review requirement data is stored; if so, acquiring the historical DAG task graph as the initial DAG task graph.

[0175] In other embodiments, the business auditing device 500 based on a large language model and dynamic DAG orchestration further includes a storage module for: generating corresponding task code based on atomic tasks, and storing the task code in association with the initial DAG task graph so as to call the task code when executing the initial DAG task graph; wherein, executing the current executable node and calling the corresponding auditing tool from the multimodal tool library and / or calling the corresponding model from the model library includes: when executing the atomic task corresponding to the current executable node, calling and running the task code corresponding to the atomic task; during the execution of the task code, calling the corresponding auditing tool from the multimodal tool library and / or calling the corresponding model from the model library.

[0176] In other implementations, the execution module 550 is further configured to: determine the predecessor node of the current executable node and obtain the cached calculation result of the predecessor node; replace the placeholder of the current executable node with the cached calculation result and execute the current executable node so as to perform business review on the document to be reviewed based on the cached calculation result.

[0177] In other implementations, the audit results include multiple sub-results corresponding to multiple nodes in the DAG task graph; the business audit device 500 based on a large language model and dynamic DAG orchestration also includes an encapsulation module for: encapsulating audit tools in a multimodal tool library through a standardized protocol interface; and / or an aggregation module for: performing unified semantic aggregation processing on multiple sub-results to obtain an audit aggregation result and output it.

[0178] It is understood that for a detailed description of the business auditing device 500 based on large language models and dynamic DAG orchestration, please refer to the description of the business auditing method based on large language models and dynamic DAG orchestration above, and will not be repeated here.

[0179] This application provides a computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements the steps of the method in any of the above embodiments.

[0180] Figure 6 A block diagram of an electronic device provided in an embodiment of this application.

[0181] This application provides an electronic device, including a memory and a processor. The memory stores a computer program, and the processor executes the computer program to implement the method in any of the above embodiments.

[0182] like Figure 6 As shown, for ease of understanding, embodiments of this application illustrate a specific electronic device.

[0183] Electronic devices are intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. Electronic devices can also represent various forms of mobile devices, such as personal digital assistants, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the present application described and / or claimed herein.

[0184] like Figure 6 As shown, the device includes a computing unit 601, which can perform various appropriate actions and processes based on a computer program stored in a read-only memory (ROM) 602 or a computer program loaded into a random access memory (RAM) 603 from a storage unit 608. The RAM 603 may also store various programs and data required for the operation of the electronic device. The computing unit 601, ROM 602, and RAM 603 are interconnected via a bus 604. An input / output (I / O) interface 605 is also connected to the bus 604.

[0185] Multiple components in the electronic device are connected to the I / O interface 605. These components include: an input unit 606, such as a keyboard or mouse; an output unit 607, such as various types of displays or speakers; a storage unit 608, such as a disk or optical disk; and a communication unit 609, such as a network interface card (NIC), a modem, or a wireless transceiver. The communication unit 609 allows the electronic device to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0186] The computing unit 601 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of the computing unit 601 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various computing units running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. The computing unit 601 performs the various methods described above. For example, in some embodiments, any one or more of the methods described above can be implemented as a computer software program tangibly contained in a machine-readable medium, such as storage unit 608. In some embodiments, part or all of the computer program can be loaded and / or installed on an electronic device via ROM 602 and / or communication unit 609. When the computer program is loaded into RAM 603 and executed by the computing unit 601, one or more steps of any one or more of the methods described above can be performed. Alternatively, in other embodiments, the computing unit 601 can be configured to perform any one or more of the methods described above by any other suitable means (e.g., by means of firmware).

[0187] It should be noted that the logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as a sequenced list of executable instructions for implementing logical functions, and can be specifically implemented in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus, or device (such as a computer-based system, a processor-included system, or other system that can fetch and execute instructions from, an instruction execution system, apparatus, or device). For the purposes of this application, "computer-readable medium" can be any means that can contain, store, communicate, propagate, or transmit programs for use by, or in conjunction with, an instruction execution system, apparatus, or device. More specific examples (a non-exhaustive list) of computer-readable media include: electrical connections (electronic devices) having one or more wires, portable computer disk drives (magnetic devices), random access memory (RAM), read-only memory (ROM), erasable and editable read-only memory (EPROM or flash memory), fiber optic devices, and portable optical disc read-only memory (CDROM). Furthermore, computer-readable media can even be paper or other suitable media on which programs can be printed, because programs can be obtained electronically, for example, by optically scanning the paper or other media, followed by editing, interpreting, or otherwise processing as necessary, and then stored in computer memory.

[0188] It should be understood that various parts of this application can be implemented using hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented using software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware, as in another embodiment, it can be implemented using any one or a combination of the following techniques known in the art: discrete logic circuits having logic gates for implementing logical functions on data signals, application-specific integrated circuits (ASICs) having suitable combinational logic gates, programmable gate arrays (PGAs), field-programmable gate arrays (FPGAs), etc.

[0189] In the description of this application, the references to terms such as "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of this application. In this application, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples.

[0190] In the description of this application, it should be understood that the terms "center", "longitudinal", "lateral", "length", "width", "thickness", "upper", "lower", "front", "rear", "left", "right", "vertical", "horizontal", "top", "bottom", "inner", "outer", "clockwise", "counterclockwise", "axial", "radial", "circumferential", etc., indicating the orientation or positional relationship based on the orientation or positional relationship shown in the accompanying drawings, are only for the convenience of describing this application and simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, or be constructed and operated in a specific orientation, and therefore should not be construed as a limitation of this application.

[0191] Furthermore, the terms "first," "second," etc., used in the embodiments of this application are for descriptive purposes only and should not be construed as indicating or implying relative importance, or implicitly specifying the number of technical features indicated in this embodiment. Therefore, features defined with terms such as "first" and "second" in the embodiments of this application can explicitly or implicitly indicate that the embodiment includes at least one of those features. In the description of this application, the word "multiple" means at least two or more, such as two, three, four, etc., unless otherwise explicitly and specifically defined in the embodiments.

[0192] In this application, unless otherwise explicitly specified or limited in the embodiments, the terms "installation," "connection," "joining," and "fixing" appearing in the embodiments should be interpreted broadly. For example, a connection can be a fixed connection, a detachable connection, or an integral part; it can also be a mechanical connection, an electrical connection, etc. Of course, it can also be a direct connection, or an indirect connection through an intermediate medium, or it can be the internal communication between two components, or the interaction between two components. Those skilled in the art can understand the specific meaning of the above terms in this application based on the specific implementation.

[0193] In this application, unless otherwise expressly specified and limited, "above" or "below" the second feature can mean that the first feature is in direct contact with the second feature, or that the first feature is in indirect contact with the second feature through an intermediate medium. Furthermore, "above," "on top of," and "over" the second feature can mean that the first feature is directly above or diagonally above the second feature, or simply that the first feature is at a higher horizontal level than the second feature. "Below," "below," and "under" the second feature can mean that the first feature is directly below or diagonally below the second feature, or simply that the first feature is at a lower horizontal level than the second feature.

Claims

1. A business auditing method based on a large language model and dynamic DAG orchestration, characterized in that, The method is applied to a large language model, and a planner, a code agent, and an executor are generated based on the large language model. The method includes: Receive documents to be reviewed and review request data; Based on the planner, semantic intent understanding and task decomposition processing are performed on the audit requirement data to determine the atomic tasks; Analyze the dependencies between the atomic tasks, and generate an initial DAG task graph based on the dependencies, wherein the initial DAG task graph includes multiple interdependent nodes; The code agent generates corresponding task code based on the atomic task, and stores the task code in association with the initial DAG task graph so that the task code can be called when the initial DAG task graph is executed; Based on the executor, the current executable node is determined from the initial DAG task graph and executed. When executing the atomic task corresponding to the current executable node, the task code corresponding to the atomic task is called and run. During the execution of the task code, the audit tool corresponding to the current executable node is called from the multimodal tool library and / or the model corresponding to the current executable node is called from the model library. The audit tool and / or the model are used to conduct business audits on the file to be audited in order to obtain audit results. The multimodal tool library is pre-configured with multiple audit tools, and the model library is pre-configured with multiple models. Each node needs to use at least one audit tool and / or at least one model when it is executed. If it is determined that the current executable node includes multiple parallel nodes, the multiple parallel nodes are executed in parallel. Diagnosis is performed based on the large language model, including performing audit anomaly diagnosis processing when the audit result indicates that the business audit has failed or the audit result does not meet the expected result, and obtaining the diagnosis result. Based on the diagnostic results, the initial DAG task graph is dynamically updated to obtain an updated DAG task graph. This includes: if the diagnostic results indicate that the auditing tool or model corresponding to a node in the initial DAG task graph has an auditing quality problem, modifying the node, wherein modifying the node includes replacing the auditing tool or model corresponding to the node, or modifying the parameters of the auditing tool or the model corresponding to the node; the nodes in the initial DAG task graph include image recognition nodes, and if the diagnostic results indicate that the data quality of the file to be audited is lower than a preset quality when the image recognition node is used to audit the file to be audited, adding an image enhancement node as a new node before the image recognition node, wherein the new node corresponds to a new auditing tool and / or a new model; Resume execution of the updated DAG task graph, wherein, when the image enhancement node is reached, the file to be reviewed is preprocessed based on the image enhancement node to improve the file data quality and obtain a preprocessed review file, and the preprocessed review file is reviewed based on the image recognition node.

2. The method according to claim 1, characterized in that, in, Dynamically updating the initial DAG task graph also includes at least one of the following: adding a feedback loop mechanism to the initial DAG task graph, wherein the feedback loop mechanism is used to wait for newly added available audit tools or new models to conduct business audits.

3. The method according to claim 2, characterized in that, The step of dynamically updating the initial DAG task graph based on the diagnostic results also includes at least one of the following: If the diagnostic result indicates that the audit tool or the model corresponding to the node in the initial DAG task graph has failed to audit, the feedback loop mechanism is added to the initial DAG task graph, and the process waits for a new available audit tool or a new model based on the feedback loop mechanism. If the diagnostic results indicate that the document to be reviewed lacks information, a manual review node is added to the initial DAG task graph.

4. The method according to claim 1, characterized in that, Before generating the initial DAG task graph, the method further includes: Determine whether to store a historical DAG task graph that matches the audit requirement data; If so, the historical DAG task graph is obtained as the initial DAG task graph.

5. The method according to claim 1, characterized in that, The execution of the currently executable node includes: Determine the predecessor node of the current executable node and obtain the cached calculation result of the predecessor node; Replace the placeholder of the current executable node with the cached calculation result, and execute the current executable node so as to perform business review on the file to be reviewed based on the cached calculation result.

6. The method according to claim 3, characterized in that, The audit results include multiple sub-results corresponding to multiple nodes in the DAG task graph; the method further includes: The auditing tools in the multimodal tool library are encapsulated through standardized protocol interfaces; and / or The multiple sub-results are subjected to unified semantic aggregation processing to obtain the audit aggregation result and output it.

7. A business approval system architecture based on a large language model and dynamic DAG orchestration, characterized in that, The system architecture, which generates a planner, a code agent, and an executor based on the large language model, includes: The application layer is configured to provide a business review interface so that users can input and receive documents to be reviewed and review requirements data through the business review interface; The access layer is configured to receive at least the file to be reviewed and the review requirement data; The tool layer is configured to provide a multimodal tool library; The model layer is configured to provide a model library; The functional layer is configured to perform semantic intent understanding and task decomposition processing on the review requirement data based on the planner to determine atomic tasks; analyze the dependencies between the atomic tasks and generate an initial DAG task graph based on the dependencies, wherein the initial DAG task graph includes multiple interdependent nodes; utilize the code agent to generate corresponding task code based on the atomic tasks, and associate and store the task code with the initial DAG task graph so as to call the task code when executing the initial DAG task graph; determine the currently executable node from the initial DAG task graph based on the executor; and based on the currently executable node, execute the task... When the atomic task corresponding to the currently executable node is executed, the task code corresponding to the atomic task is called and run. During the execution of the task code, the audit tool corresponding to the currently executable node is called from the multimodal tool library and / or the model corresponding to the currently executable node is called from the model library. The audit tool and / or the model are used to perform a business audit on the file to be audited to obtain an audit result. The multimodal tool library is pre-configured with multiple audit tools, and the model library is pre-configured with multiple models. Each node needs to use at least one audit tool and / or at least one model during execution. When the currently executable node is determined... In the case of multiple parallel nodes, the multiple parallel nodes are executed in parallel; diagnosis is performed based on the large language model, including performing audit anomaly diagnosis processing when the audit result indicates that the business audit has failed or the audit result does not meet expectations, and obtaining a diagnosis result; based on the diagnosis result, the initial DAG task graph is dynamically updated to obtain an updated DAG task graph, including: when the diagnosis result indicates that the audit tool or model corresponding to a node in the initial DAG task graph has an audit quality problem, the node is modified, wherein modifying the node includes replacing the audit tool or model corresponding to the node, or modifying the model corresponding to the node. The parameters of the auditing tool or the parameters of the model; the nodes of the initial DAG task graph include image recognition nodes. If the diagnostic result indicates that the data quality of the file to be audited is lower than a preset quality when the image recognition node is used to audit the file to be audited, an image enhancement node is added as a new node before the image recognition node. The new node corresponds to a new auditing tool and / or a new model. The updated DAG task graph is resumed, wherein when the image enhancement node is executed, the file to be audited is preprocessed based on the image enhancement node to improve the file data quality and obtain a preprocessed audit file, and the preprocessed audit file is audited based on the image recognition node. The resource layer is configured to store at least the DAG task graph, the cached calculation results of each node, and the audit results.

Images