Method for debugging intelligent agent through computing power of intelligent computing center

Abstract

The invention provides a method for debugging an intelligent agent through computing power of an intelligent computing center, which comprises the following steps: S1, a debugging intelligent agent receives task information provided by a user through an interactive interface, and the task information is used for indicating to debug a debugged object; the debugged object is a debugged intelligent agent or a function module or a tool function of the debugged intelligent agent; s2, the debugging agent determines a debugging requirement according to the task information; s3, the debugging agent determines a debugging method according to the debugging requirement, deploys a debugging environment according to the debugging method, generates a running instruction and debugs the debugged object; s4, the debugging agent obtains the operation information of the debugged object and analyzes the operation information, and whether the debugging requirement is met or not is evaluated according to the analysis result; s5, if not, the debugging agent checks the code of the debugged object, modifies the code according to the check result, and returns to the step S3 until the condition is met; and S6, the debugging agent feeds back a debugging result to the user through the interactive interface.

Description

Technical Field

[0001] The present invention relates to the technical fields of intelligent computing centers, intelligent computing centers, and computing power infrastructure, and particularly relates to a method for an intelligent agent to debug an intelligent agent through the computing power of an intelligent computing center. Background Art

[0002] With the rapid development of artificial intelligence technology, "intelligent computing centers" and "intelligent computing centers" have emerged as the times require.

[0003] An "intelligent computing center" refers to a facility that uses large-scale heterogeneous computing power resources, including general computing power and intelligent computing power, and mainly provides the required computing power, data, and algorithms for artificial intelligence applications (such as scenarios for artificial intelligence deep learning model development, model training, and model inference, etc.). The intelligent computing center covers facilities, hardware, and software, and can provide full-stack capabilities from underlying computing power to top-level application enabling.

[0004] The "intelligent computing center" includes, but is not limited to, the "intelligent computing center".

[0005] An "intelligent computing center", that is, an artificial intelligence computing center, is a type of computing power infrastructure that is based on artificial intelligence theory, adopts an artificial intelligence computing architecture, and provides computing power services, data services, and algorithm services required for artificial intelligence applications.

[0006] "Computing power" is the core of "intelligent computing centers" and "intelligent computing centers". It is the ability of computer devices or computing / data centers to process information, the ability of computer hardware and software to cooperate to jointly execute a certain computing requirement, the computing ability to achieve the output of target results through processing information data, and a new type of productive force that integrates information computing power, network carrying capacity, and data storage capacity. It mainly provides services to society through computing power infrastructure.

[0007] An "intelligent agent" is an agent that can perceive the environment and take actions to achieve specific goals. It can be software, hardware, or a system, and has autonomy, adaptability, and interaction capabilities. The intelligent agent perceives changes in the environment (such as through sensors or data input), makes judgments and decisions based on the knowledge and algorithms learned by itself, and then executes actions to affect the environment or achieve a predetermined goal. Intelligent agents are widely used in the field of artificial intelligence, and are commonly found in automated systems, robots, virtual assistants, and game characters, etc. The core lies in its ability to learn independently and evolve continuously to better complete tasks and adapt to complex environments.

[0008] The debugging of intelligent agents is a complex process. Currently, it needs to be completed by personnel who simultaneously have profound artificial intelligence expertise and domain knowledge. The debugging cost is high and the debugging efficiency is low. Summary of the Invention

[0009] The present invention provides a method for an intelligent agent to debug an intelligent agent through the computing power of an intelligent computing center, which is used to solve the problems of high debugging cost and low debugging efficiency of the intelligent agent.

[0010] To solve the above technical problems, the present invention is implemented as follows:

[0011] In a first aspect, the present invention provides a method for an intelligent agent to debug an intelligent agent through the computing power of an intelligent computing center, including:

[0012] Step S1: The debugging intelligent agent receives task information provided by the user through an interaction interface, where the task information is used to indicate debugging of the object to be debugged, and the object to be debugged is the intelligent agent to be debugged, or a functional module or tool function of the intelligent agent to be debugged;

[0013] Step S2: The debugging intelligent agent determines debugging requirements according to the task information, and the debugging requirements include: the object to be debugged, the debugging environment, the debugging expectation, and test cases;

[0014] Step S3: The debugging intelligent agent determines a debugging method according to the debugging requirements, deploys the debugging environment according to the debugging method, generates a running instruction, and debugs the object to be debugged;

[0015] Step S4: The debugging intelligent agent obtains the running information of the object to be debugged, analyzes the running information, and evaluates whether the debugging requirements are met according to the analysis result; the running information includes at least one of the following: running status, running log, intermediate data, running result, metric data, and resource occupancy information;

[0016] Step S5: When the debugging requirements are not met, the debugging intelligent agent checks the code of the object to be debugged, modifies the code according to the check result, and returns to Step S3 until the debugging requirements are met;

[0017] Step S6: The debugging intelligent agent feeds back the debugging result to the user through the interaction interface.

[0018] Optionally, the functional modules of the intelligent agent to be debugged include at least one of the following: a perception module, a thought chain module, a decision-making module, a reflection module, a memory module, a learning module, a tool framework module, and necessary framework or system modules.

[0019] Optionally, Step S2 includes:

[0020] Step S21: The debugging intelligent agent communicates with the user through the interaction interface at least once according to the task information to confirm the debugging requirements.

[0021] Optionally, Step S3 includes:

[0022] Step S31: The debugging agent determines a debugging method according to the debugging requirements, deploys the debugging environment according to the debugging method, generates a running instruction, and debugs the object to be debugged. The debugging method includes at least one of the following: debugging based on the command line, debugging based on an interface, debugging based on web technology, or debugging based on computer vision.

[0023] Optionally, after step S4, the following steps are further included:

[0024] Step S6: When the debugging requirements are met, the debugging agent stores the debugging process information and the repair process information in the knowledge base of the intelligent computing center. The debugging process information includes: the input and output of debugging, the running log, the intermediate data, the return data of the interface, the feedback of the browser, the screenshot picture. The repair process information includes: the code before modification, the code after modification, the modification record log.

[0025] Optionally, the debugging agent includes one or more agents, and the multiple agents include at least one of the following: a running agent, a debugging environment deployment agent, a monitoring agent, a requirement confirmation agent, a code generation agent, a code compilation agent, an evaluation agent.

[0026] In a second aspect, the present invention provides a device for implementing an agent to debug an agent through the computing power of an intelligent computing center, including:

[0027] A task receiving module, configured to receive task information provided by a user through an interaction interface, where the task information is used to indicate debugging of an object to be debugged, and the object to be debugged is a debugging agent, or a functional module or a tool function of the debugging agent;

[0028] A debugging requirement determination module, configured to determine debugging requirements according to the task information, where the debugging requirements include: an object to be debugged, a debugging environment, a debugging expectation, and a test case;

[0029] A deployment and running module, configured to determine a debugging method according to the debugging requirements, deploy the debugging environment according to the debugging method, generate a running instruction, and debug the object to be debugged;

[0030] A monitoring and evaluation module, configured to obtain the running information of the object to be debugged, analyze the running information, and evaluate whether the debugging requirements are met according to the analysis result; the running information includes at least one of the following: a running state, a running log, intermediate data, a running result, metric data, and resource occupancy information;

[0031] A code generation module, configured to, when the debugging requirements are not met, check the code of the object to be debugged, modify the code according to the check result, and trigger the deployment and operation module and the monitoring and evaluation module to continue working until the debugging requirements are met;

[0032] A feedback module, configured to feedback the debugging result to the user through an interaction interface.

[0033] In a third aspect, the present invention provides an electronic device, including: a processor, a memory, and a program stored on the memory and executable on the processor, and when the program is executed by the processor, the steps of the method for implementing intelligent agent debugging of an intelligent agent through the computing power of an intelligent computing center as described in the first aspect above are realized.

[0034] In a fourth aspect, the present invention provides a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, the steps of the method for implementing intelligent agent debugging of an intelligent agent through the computing power of an intelligent computing center as described in the first aspect above are realized.

[0035] In a fifth aspect, the present invention provides a computer program product, including computer instructions, and when the computer instructions are executed by a processor, the steps of the method for implementing intelligent agent debugging of an intelligent agent through the computing power of an intelligent computing center as described in the first aspect above are realized.

[0036] In the present invention, through the debugging intelligent agent running in the intelligent computing center, it is possible to communicate with the user and confirm clear and detailed debugging requirements, automatically complete the debugging of the intelligent agent to be debugged, or the functional modules or tool functions of the intelligent agent to be debugged, replacing the process of manual debugging of the intelligent agent, thereby effectively saving the debugging cost, and the intelligent computing center can provide sufficient computing power resources, greatly improving the debugging efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0037] By reading the following detailed description of the preferred embodiments, various other advantages and benefits will become clear to those of ordinary skill in the art. The drawings are only for the purpose of showing the preferred embodiments and are not considered to be a limitation of the present invention. Moreover, throughout the drawings, the same reference numerals are used to represent the same components. In the drawings:

[0038] Figure 1 is a schematic flowchart of the method for implementing intelligent agent debugging of an intelligent agent through the computing power of an intelligent computing center according to the present invention;

[0039] Figure 2 is a schematic structural diagram of the device for implementing intelligent agent debugging of an intelligent agent through the computing power of an intelligent computing center according to the present invention;

[0040] Figure 3Schematic diagram of the structure of the electronic device according to the present invention. Detailed implementation manners

[0041] The technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings in the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, rather than all of the embodiments. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present invention without creative efforts shall fall within the protection scope of the present invention.

[0042] First, the technical terms related to the present invention will be briefly described below.

[0043] The "computing power" referred to in the present invention means: the ability of a computer device or a computing / data center to process information, the ability of computer hardware and software to cooperate to jointly execute a certain computing requirement, the computing ability to output a target result by processing information data, a new type of productive force integrating information computing power, network carrying capacity, and data storage capacity, and mainly providing services to society through computing power infrastructure.

[0044] The "computational power" (Computational Power, CP) referred to in the present invention means: the ability of a data center server to process data and output results, a comprehensive index for measuring the computing ability of a data center, including general computing ability, supercomputing ability, and intelligent computing ability. The commonly used measurement unit is the number of floating-point operations per second (FLOPS, 1EFLOPS = 10^18 FLOPS), and the larger the value, the stronger the comprehensive computing ability. It is estimated that 1EFLOPS is approximately the computing power output of 5 Tianhe 2A or 500,000 mainstream server CPUs or 2 million mainstream laptops. The calculation formula is: CP = CP_general + CP_intelligent + CP_super

[0045] The "carrying capacity" (Network Power, NP) referred to in the present invention means: the performance of the data transmission ability of computing power facilities, a comprehensive ability including network architecture, network bandwidth, transmission delay, intelligent management and scheduling, etc., involving network transmission inside and between data centers, and a comprehensive index for measuring network transmission scheduling ability.

[0046] The "Storage Power" (SP) described in the present invention refers to the comprehensive ability of a data center in four aspects: data storage capacity, performance, security and reliability, and green and low-carbon. It is a comprehensive indicator for measuring the data storage capacity of a data center, including external storage devices such as storage arrays and built-in storage devices of servers. The commonly used measurement unit for storage capacity is exabyte (EB, 1EB = 2^60 bytes), the commonly used measurement unit for performance is the number of read / write operations per second per unit capacity (IOPS / TB, Input / Output Operations Per Second / TB), and the disaster recovery ratio is an important manifestation of security and reliability.

[0047] The "computing power infrastructure" described in the present invention refers to a new type of information infrastructure that integrates information computing power, network carrying capacity, and data storage power. It can realize the centralized computing, storage, transmission, and application of information, presenting characteristics such as multi-element ubiquitous, intelligent and agile, secure and reliable, and green and low-carbon. It is of great significance for boosting industrial transformation and upgrading, empowering China's scientific and technological innovation, meeting people's beautiful life, and realizing high-efficiency social governance.

[0048] The "new type of information infrastructure" described in the present invention mainly includes network infrastructures such as 5G networks, fiber broadband networks, backbone networks, international communication networks, and satellite Internet, computing power infrastructures such as data centers, general computing power centers, intelligent computing centers, and supercomputing centers, and new technology facilities such as artificial intelligence, blockchain, and quantum computing. With the emergence and popularization of new general technologies, the form of the new type of information infrastructure will be more rich and diverse.

[0049] The "computing power" described in the present invention includes: general computing power, intelligent computing power, and super computing power.

[0050] The "general computing power" described in the present invention refers to the computing ability provided by servers based on CPU (Central Processing Unit) chips, which is used to support basic general computing such as cloud computing and edge computing.

[0051] The "intelligent computing power" described in the present invention refers to a computing platform for various artificial intelligence innovation applications, which is based on the large-scale deployment of dedicated chips such as GPU (Graphics Processing Unit), FPGA (Field Programmable Gate Array), and ASIC (Application Specific Integrated Circuit), such as natural language processing, machine vision, and so on.

[0052] The "super computing power" described in the present invention refers to: mainly the computing power provided by high-performance computing clusters such as supercomputers. It utilizes the centralized computing resources of multiple computer systems working in parallel and processes extremely complex or data-intensive problems through a dedicated operating system. It is mainly used for computing in cutting-edge scientific fields, such as planetary simulation, drug molecule design, gene analysis, etc.

[0053] The "intelligent computing center" described in the present invention refers to: a facility that provides the required computing power, data, and algorithms mainly for artificial intelligence applications (such as scenarios like artificial intelligence deep learning model development, model training, and model inference) by using large-scale heterogeneous computing power resources, including general computing power (CPU) and intelligent computing power (GPU, FPGA, ASIC, etc.). The intelligent computing center covers facilities, hardware, and software and can provide full-stack capabilities from underlying computing power to top-level application enabling.

[0054] The "intelligent computing center" described in the present invention includes, but is not limited to, the "intelligent computing center".

[0055] The "intelligent computing center" described in the present invention, namely the artificial intelligence computing center, is a type of computing power infrastructure based on artificial intelligence theory, adopting an artificial intelligence computing architecture, and providing computing power services, data services, and algorithm services required for artificial intelligence applications.

[0056] The "computing power center" described in the present invention refers to: a facility mainly composed of infrastructure such as wind, fire, water, and electricity and IT software and hardware devices, with computing power, transportation power, and storage power, including general data centers, intelligent computing centers, supercomputing centers, etc.

[0057] The "supercomputing center" described in the present invention refers to: namely the supercomputing data center, which is a data center based on supercomputers or large-scale computing clusters and can provide functions such as large-scale computing, storage, and network services, and is widely used in application scenarios such as aerospace, national defense, oil exploration, climate modeling, and genome sequencing.

[0058] The "computing power resources" described in the present invention refers to: technologies and facilities required for the development of the digital society with information computing, transmission, storage, and application capabilities, including but not limited to computing resources such as CPU and GPU, network resources such as switches and routers, storage resources such as storage arrays and distributed storage, security resources such as firewalls and intrusion detection systems, and support and guarantee resources such as wind, fire, water, and electricity.

[0059] The "large language model" described in the present invention refers to the large language model (LLM), which is a language model with a relatively large number of parameters, aiming to understand and generate human language, trained through a large amount of text data, and can perform a wide range of tasks including text summarization, translation, sentiment analysis, etc.

[0060] The "Agent" described in the present invention refers to an agent that can perceive the environment and take actions to achieve specific goals. It can be software, hardware, or a system, and has autonomy, adaptability, and interaction capabilities. The agent perceives changes in the environment (such as through sensors or data input), makes judgments and decisions based on the knowledge and algorithms it has learned, and then executes actions to affect the environment or achieve a predetermined goal. Agents are widely used in the field of artificial intelligence and are commonly found in automated systems, robots, virtual assistants, and game characters, etc. The core lies in the ability to learn autonomously and continuously evolve to better complete tasks and adapt to complex environments.

[0061] The "tool function" described in the present invention can also be referred to as a "tool method", which is an executable function method called by the agent to complete a specific task; it is an executable function method selected and called by the agent according to the task context; and it aims to intelligently construct parameters and dynamically call using a large language model to complete the subtasks of the task.

[0062] To solve the problems of high debugging cost and low debugging efficiency of agents in related technologies, please refer to Figure 1 , the present invention provides a method for debugging an agent by using the computing power of an intelligent computing center, and the method includes:

[0063] Step S1: The debugging agent receives task information provided by the user through an interaction interface, and the task information is used to indicate the debugging of the object to be debugged, where the object to be debugged is the agent to be debugged, or a functional module or tool function of the agent to be debugged;

[0064] The "debugging agent" described in the present invention is constructed based on a large language model and has the ability to debug other agents, or functional modules or tool functions of other agents, and can communicate with the user in a dialogue through natural language processing on the interaction interface.

[0065] In the present invention, the debugging agent can be one agent or multiple agents. The multiple agents form a multi-agent cooperation system, and each agent has specific capabilities. The multiple agents can cooperate in a dialogue communication manner on the interaction interface to complete the task of debugging the agent to be debugged, or a functional module or tool function of the agent to be debugged. The interaction interface can display the communication process between the multiple agents during the execution of the task.

[0066] In the present invention, the intelligent agent to be debugged may be an intelligent agent that has been developed to complete a specified task, such as data analysis, large language model training (which can also be referred to as fine-tuning a large language model), computing power management of an intelligent computing center, financial reimbursement, travel planning, etc.

[0067] In the present invention, the entire intelligent agent to be debugged can be debugged, or only a functional module or a tool function of the intelligent agent to be debugged can be debugged.

[0068] Step S2: The debugging intelligent agent determines the debugging requirements according to the task information, and the debugging requirements include: the object to be debugged, the debugging environment, the debugging expectation, and the test case.

[0069] In some embodiments, optionally, the debugging intelligent agent can obtain the material information of the object to be debugged according to the task information, and determine the debugging requirements according to the material information. The material information may include, for example, at least one of the requirement document, design document, and operation and maintenance document of the object to be debugged.

[0070] Among them, the debugging environment refers to the environment for running the code of the object to be debugged. For example, for the hardware requirements of the debugging environment, basic parameters such as the CPU model, memory capacity, and hard disk space need to be clarified; the language environment requires Python 3.11.3, and dependency packages such as transformer, torch, and openai need to be installed, and the version numbers should be listed in detail; in terms of storage requirements, it includes the necessary storage size and the space size for temporary file storage, etc. This part of the debugging information may be obtained by confirming with the user, or determined according to the documents provided by the user and the existing documents of the intelligent agent (Agent) product.

[0071] Among them, the debugging expectation refers to the effect to be achieved by debugging. For example, if the intelligent agent to be debugged is an intelligent agent for fine-tuning a large language model, the debugging expectation may be to ensure that the large language model after fine-tuning of the intelligent agent to be debugged can correctly process NL2SQL tasks.

[0072] Among them, the test case is a case used to verify the function of the object to be debugged, and may include the input and output requirements of the debugging.

[0073] Step S3: The debugging intelligent agent determines the debugging method according to the debugging requirements, deploys the debugging environment according to the debugging method, generates a running instruction, and debugs the object to be debugged.

[0074] The object to be debugged runs in the debugging environment according to the running instruction and feeds back the running result to the debugging agent; if a module or a tool function of the object to be debugged is debugged alone, the debugging agent triggers the running of the module or the tool function and collects the output result.

[0075] Step S4: The debugging agent obtains the running information of the object to be debugged, analyzes the running information, and evaluates whether the debugging requirements are met according to the analysis result; the running information includes at least one of the following: running status, running log, intermediate data, running result, metric data, and resource occupancy information;

[0076] The resource occupancy information refers to the occupancy information of the computing power resources of the intelligent computing center, such as memory occupancy, GPU occupancy, etc.

[0077] Evaluating whether the debugging requirements are met according to the analysis result may be, for example: evaluating whether the running result meets the output requirements in the test case, whether the concurrent processing ability of the agent meets the requirements in the debugging expectation, or whether the intermediate data meets the requirements in the debugging expectation, etc.

[0078] Step S5: When the debugging requirements are not met, the debugging agent checks the code of the object to be debugged, modifies the code according to the check result, and returns to Step S3 until the debugging requirements are met;

[0079] Step S6: The debugging agent feeds back the debugging result to the user through the interaction interface.

[0080] It should be noted that when the object to be debugged is the debugging agent, the debugging agent can check the entire code of the debugging agent; when the object to be debugged is a functional module or a tool function of the debugging agent, the debugging agent can check the code of the functional module or the tool function of the debugging agent, and can not check the code of other parts of the debugging agent.

[0081] In some embodiments, optionally, the debugging agent modifies the code according to the running log, intermediate data, metric data, and / or the running result.

[0082] In some embodiments, optionally, the debugging agent also needs to compile the modified code.

[0083] In the present invention, the debugging agent running in the intelligent computing center can communicate with the user to confirm clear and detailed debugging requirements, and automatically complete the debugging of the debugged agent, or the functional modules or tool functions of the debugged agent, replacing the process of manually debugging the agent, thereby effectively saving the debugging cost, and the intelligent computing center can provide sufficient computing power resources to greatly improve the debugging efficiency.

[0084] In some embodiments, optionally, the functional modules of the debugged agent include at least one of the following: a perception module, a thought chain module, a decision-making module, a reflection module, a memory module, a learning module, a tool framework module, and necessary framework or system modules.

[0085] Among them, the perception module is used to receive and process external inputs (such as text, images, and voices);

[0086] The thought chain module is used to simulate the reasoning process of humans, decompose complex problems into multiple steps, and solve them step by step;

[0087] The decision-making module is used to generate an optimal action plan or answer according to the input information and goals;

[0088] The reflection module is used to evaluate and improve its own behaviors, decisions, and reasoning processes;

[0089] The memory module is used to store and retrieve information, supporting long-term memory and short-term memory;

[0090] The learning module is used to continuously update the agent's knowledge through data, documents, or interactions to facilitate the completion of specific tasks;

[0091] The tool framework module is the underlying framework module of the tool function to support the extension, definition, and invocation of more tool functions;

[0092] The necessary framework or system modules include the overall framework of the debugged agent, template classes, and communication frameworks, etc., to support the connection and cooperation of the above-mentioned various modules.

[0093] In some embodiments, optionally, the step S2 includes:

[0094] Step S21: The debugging agent communicates with the user through the interaction interface at least once according to the task information to confirm the debugging requirements.

[0095] In some embodiments, the task information given by the user may be relatively simple. In this case, the debugging agent can actively communicate with the user through the interaction interface one or more times to obtain more clear and detailed debugging requirements.

[0096] The following is an example to illustrate the communication process between the user and the debugging agent in the present invention.

[0097] In one example, the conversation between the user and the debugging agent in the interaction interface is as follows:

[0098] "User: Please debug the overall process of the large language model fine-tuning agent to ensure that it can use the / mnt / data / sft_data / nl2sql_train.json data to fine-tune Llama-3.1-8B-Instruct. The relevant documents regarding the requirements, design, and operation and maintenance of the large language model fine-tuning agent are placed under / mnt / docs / sft_agent / .

[0099] Debugging agent: Okay, allow me to first check the relevant information. Please wait a moment...

[0100] The following is the relevant knowledge obtained from various materials:

[0101] 1. The requirements document clearly states that the agent needs to support multi-model fine-tuning, and the current task is for Llama-3.1-8B-Instruct;

[0102] 2. The code repository path is / mnt / code / sft_agent, and the dependent conda environment name is llama-sft (Python 3.11.3);

[0103] 3. The pre-trained model repository is in / mnt / models / , and it is confirmed that / mnt / models / llama / llama-3.1-8B-Instruct exists;

[0104] 4. Analyzing the code, the running entry is python / mnt / code / sft_agent / run.py --config configs / finetune_cfg.yaml;

[0105] 5. The log path is / mnt / logs / sft_agent / training_$(date +%Y%m%d).log;

[0106] 6. The API service address dependent on Meta-Llama-3-70B is llm-api.prod.internal:8443;

[0107] Do you want me to use / mnt / data / sft_data / nl2sql_train.json as the training set to verify whether the agent can complete the fine-tuning process?

[0108] User: Yes, and it is necessary to ensure that the fine-tuned model can correctly handle the NL2SQL task;

[0109] Debugging Agent: I have reviewed the training data. The following is the format of the first sample:

[0110]

[0111] This is a typical natural language to SQL task. After fine-tuning, how can the quality of the generated SQL be verified? Is it necessary to perform result verification?

[0112] User: It is possible to connect to the test database. The connection information is as follows:

[0113] Type: MySQL

[0114] Address: dbserver.prod.internal:3306

[0115] Database: sales_test

[0116] Account: ********

[0117] Password: ********

[0118] Syntax check and result sampling verification need to be performed before execution.

[0119] Debugging Agent: Does the test dataset contain the expected execution results? For example, does the " / mnt / data / test_data / nl2sql_test.json" contain the "expected_result" field?

[0120] User: The test set already contains the expected results. The path is " / mnt / data / test_data / nl2sql_test_202404_v1.json". Each piece of data has the "expected_result" field. An example is as follows:

[0121]

[0122] Debugging Agent: When debugging and encountering code problems, I plan to: create a new branch "feature / sft_debug_v1" in " / mnt / code / sft_agent" to avoid affecting the existing code and facilitate version rollback. Is this operation mode allowed?

[0123] User: Yes.

[0124] Debugging Agent: Finally, confirm the debugging goal:

[0125] Debug the large language model fine-tuning agent to ensure that it supports fine-tuning based on / mnt / data / sft_data / nl2sql_train.json and Llama-3.1-8B-Instruct;

[0126] Sample a few simple examples from the test set to ensure that the fine-tuned model generates SQL statements;

[0127] Initially determine to use 8 × A100 nodes to complete the feasibility verification of fine-tuning the model Llama-3.1-8B-Instruct using the fine-tuning function of the large language model fine-tuning agent;

[0128] Are there any additional requirements?

[0129] User: Pay attention to some of the proprietary terms in our business department.

[0130] Debugging agent: Okay, I will first sort out our proprietary terms and organize the matching relationships between the proprietary terms and the fields. Is there anything else to add?

[0131] User: There are no other requirements for now.

[0132] Debugging agent: Received.

[0133] Among them, the above examples are for debugging the fine-tuning function of the large language model fine-tuning agent (i.e., the agent to be debugged).

[0134] The above "Llama-3.1-8B-Instruct" is the name of the large language model to be fine-tuned. In this embodiment, the large language model to be fine-tuned is a model for completing the NL2SQL task (natural language to SQL task).

[0135] The above "code repository path" refers to the storage path of the code of the large language model fine-tuning agent.

[0136] The above "llama-sft (Python 3.11.3)" is the dependency environment of the large language model fine-tuning agent, that is, the above debugging environment.

[0137] The above "pre-trained model repository" refers to the storage location of the large language model to be fine-tuned.

[0138] The above "the API service address depending on Meta-Llama-3-70B is llm-api.prod.internal:8443" is used to indicate the call interface of the large language model.

[0139] The above-mentioned " / mnt / data / sft_data / nl2sql_train.json" refers to test cases.

[0140] From the above example, it can be seen that the debugging agent can communicate with the user multiple times to determine more detailed debugging requirements.

[0141] In some embodiments, optionally, step S3 includes:

[0142] Step S31: The debugging agent determines a debugging method according to the debugging requirements, deploys the debugging environment, generates a running instruction and debugs the object to be debugged according to the debugging method. The debugging method includes at least one of the following: debugging based on the command line, debugging based on an interface, debugging based on web technology, or debugging based on computer vision.

[0143] Among them, the debugging based on the command line means that the debugging agent interacts with the agent to be debugged through the command line. The debugging agent inputs debugging instructions or parameters (i.e., the above-mentioned running instructions) in the command line. These instructions and parameters can be used as command line input parameters in the form of code calls or can be executed in an environment such as the command prompt line or Shell through an automation framework. During this process, the debugging agent can obtain the running information of the agent to be debugged in real time, such as the running status, running log, intermediate data, and the final running result, etc.

[0144] The debugging based on web technology means that the debugging agent simulates the user's viewing and operation of the web page (i.e., the above-mentioned running instructions) by capturing and operating DOM (Document Object Model) elements in the browser, triggers the specific function running of the agent to be debugged, and monitors the running information of the agent in the browser or the changes of DOM elements in real time (i.e., the above-mentioned running information) to verify whether the behavior of the agent meets the debugging expectations.

[0145] The debugging based on computer vision is that the debugging agent captures visual information (such as screenshots, video streams, or sensor data) (i.e., the above-mentioned running information) during the running process of the agent, combines multi-modal image recognition technology to analyze the behavior and environmental interaction of the agent, and then conducts debugging.

[0146] In the same debugging scenario, multiple debugging methods may be used simultaneously to meet the debugging requirements.

[0147] The following is an example to illustrate the process of the debugging agent in the present invention for debugging the fine-tuning function of the large language model fine-tuning agent.

[0148] 1. Operation environment connection:

[0149] The debugging agent uses computer vision methods to capture the current Windows interface and analyze the current state with a multimodal model. It is confirmed that it is necessary to connect to the server first, use command-line debugging techniques to open the Shell tool, and use an automation framework to log in to the computing power 8×A100 server node of the intelligent computing center in the Shell.

[0150] 2. Service startup and verification:

[0151] The debugging agent uses the automation framework to start the large language model fine-tuning agent application through the Shell command line.

[0152] Next, use computer vision methods to take a screenshot of the current Windows interface to observe whether the agent starts normally.

[0153] After determining that the agent has started, use interface debugging techniques to generate Python code for response testing to verify whether the agent's response is running normally. If the expected result is returned (such as {"response":"Hello,world!"}), the large language model fine-tuning agent application starts successfully.

[0154] 3. Input fine-tuning request:

[0155] The debugging agent uses web debugging techniques to open a browser to access the access page of the fine-tuning agent. After logging in, enter the agent conversation window and input:

[0156] ```

[0157] Please use the / mnt / data / sft_data / nl2sql_train.json data to fine-tune / mnt / models / llama / llama-3.1-8B-Instruct, and save the fine-tuned weights to / mnt / results / llama / v1 / llama-3.1-8B-Instruct-NL2SQL.

[0158] ```

[0159] And click send.

[0160] 4. Real-time monitor the running status of the fine-tuning task:

[0161] The debugging agent uses web debugging techniques to observe the feedback results in the browser page in real time.

[0162] Meanwhile, the debugging agent takes screenshots at regular intervals through the visual debugging method, observes the running logs in the Shell, analyzes the execution status of the fine-tuning task, and checks for any anomalies during the fine-tuning process (such as OOM errors or data loading failures). It also uses interface debugging technology to call the monitoring center interface and check the GPU usage rate, memory occupancy, etc. of the resources. If an anomaly is detected, the debugging agent will automatically record the relevant logs and attempt to reconfigure or fix the problem.

[0163] 5. Verify the running result:

[0164] The debugging agent uses the computer vision debugging method to obtain screenshots and observe the running result. For example, capture a screenshot of the feedback of the large language model fine-tuning agent in the dialog box after fine-tuning is completed, and analyze the key information in the result page (such as the "fine-tuning completed" prompt, output path, etc.) in combination with multi-modal image recognition technology.

[0165] The debugging agent can also use the command-line debugging method with the help of an automation framework to verify whether the fine-tuned model can be loaded and run normally.

[0166] For example, the command line can be as follows:

[0167]

[0168] That is, in the embodiments of the present invention, before generating the running instruction and sending it to the object to be debugged in the above step S3, it can also:

[0169] Connect to the operating environment according to the debugging method;

[0170] Start the object to be debugged. Optionally, it can also verify whether the object to be debugged is successfully started.

[0171] In the embodiments of the present invention, the above step S4 can also include:

[0172] Step S41: Obtain the running information of the object to be debugged based on the determined debugging method.

[0173] In some embodiments, optionally, after the above step S4, it further includes:

[0174] Step S7: When the debugging requirements are met, the debugging agent stores the debugging process information and the repair process information in the knowledge base of the intelligent computing center. The debugging process information includes: the input and output of the debugging, the running logs, the intermediate data, the return data of the interface, the feedback of the browser, the screenshots, and the repair process information includes: the code before modification, the code after modification, and the modification record logs.

[0175] The above debugging process information and repair process information can be used for subsequent debugging.

[0176] In the above embodiments, it is mentioned that the debugging agent may include multiple agents, and the multiple agents include at least one of the following agents: a running agent, a debugging environment deployment agent, a monitoring agent, a requirement confirmation agent, a code generation agent, a code compilation agent, and an evaluation agent.

[0177] Among them, the requirement confirmation agent is used to confirm the debugging requirements with the user; the running agent is used to generate a running instruction and send it to the object to be debugged; the debugging environment deployment agent is used to deploy the debugging environment; the monitoring agent is used to monitor the running log, intermediate data, and running result of the object to be debugged; the code generation agent is used to check the code of the object to be debugged and modify the code according to the check result; the code compilation agent is used to perform necessary compilation on the code; the evaluation agent analyzes the running log, intermediate data, and running result, and evaluates whether the debugging requirements are met according to the analysis result.

[0178] In some embodiments, S6 further includes:

[0179] Step S61: The debugging agent feeds back the debugging result to the user through the interaction interface, and the debugging result may include at least one of the following: notifying the user that the debugging of the object to be debugged has been completed, the storage location of the debugged code (such as a download link), etc.

[0180] Optionally, if after modifying the code and debugging it multiple times (for example, exceeding the set upper limit of the number of times), the code of the object to be debugged still does not meet the debugging requirements, the debugging agent can terminate the debugging and feed back a debugging report to the user.

[0181] Please refer to Figure 2 , the present invention also provides a device 10 for realizing the debugging of the debugging agent through the computing power of the intelligent computing center, including:

[0182] A task receiving module 11, configured to receive task information provided by the user through the interaction interface, where the task information is used to indicate debugging of an object to be debugged, and the object to be debugged is a debugging agent, or a functional module or tool function of the debugging agent;

[0183] A debugging requirement determination module 12, configured to determine debugging requirements according to the task information, where the debugging requirements include: the object to be debugged, the debugging environment, the debugging expectation, and the test case;

[0184] A deployment and operation module 13 is used to determine a debugging method according to the debugging requirements, deploy the debugging environment according to the debugging method, generate operation instructions and debug the object to be debugged;

[0185] A monitoring and evaluation module 14 is used to obtain the operation information of the object to be debugged, analyze the operation information, and evaluate whether the debugging requirements are met according to the analysis results; the operation information includes at least one of the following: operation status, operation log, intermediate data, operation result, metric data, and resource occupancy information;

[0186] A code generation module 15 is used to, when the debugging requirements are not met, check the code of the object to be debugged, modify the code according to the check results, and trigger the deployment and operation module and the monitoring and evaluation module to continue working until the debugging requirements are met;

[0187] A feedback module 16 is used to feedback the debugging results to the user through an interaction interface.

[0188] In some embodiments, optionally, the functional modules of the agent to be debugged include at least one of the following: a perception module, a thought chain module, a decision-making module, and a reflection module 、 a memory module, a learning module, a tool framework module, and necessary framework or system modules.

[0189] In some embodiments, optionally, the debugging requirement determination module 12 is used to communicate with the user through the interaction interface at least once according to the task information to confirm the debugging requirements.

[0190] In some embodiments, optionally, the deployment and operation module 13 is used to determine a debugging method according to the debugging requirements, deploy the debugging environment according to the debugging method, generate operation instructions and debug the object to be debugged, and the debugging method includes at least one of the following: command-line-based debugging, interface-based debugging, web technology-based debugging, or computer vision-based debugging.

[0191] In some embodiments, optionally, the device 10 for debugging an agent through the computing power of an intelligent computing center further includes:

[0192] A storage module is used to, when the debugging requirements are met, store the debugging process information and the repair process information into the knowledge base of the intelligent computing center, where the debugging process information includes: input and output of debugging, the operation log, the intermediate data, return data of the interface, feedback of the browser, captured screen images, and the repair process information includes: code before modification, code after modification, and modification record log.

[0193] Please refer to Figure 3, the present invention also provides an electronic device 20, including a processor 21, a memory 22, and a computer program stored on the memory 22 and executable on the processor 21. When the computer program is executed by the processor 21, it implements each process of the method embodiment for implementing agent debugging of an agent through the computing power of an intelligent computing center, and can achieve the same technical effects. To avoid repetition, it will not be elaborated here.

[0194] The present invention also provides a computer-readable storage medium, on which a computer program is stored. When the computer program is executed by a processor, it implements each process of the method embodiment for implementing agent debugging of an agent through the computing power of an intelligent computing center, and can achieve the same technical effects. To avoid repetition, it will not be elaborated here. Among them, the computer-readable storage medium is, for example, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disc, etc.

[0195] The embodiment of the present application also provides a computer program product, including computer instructions. When the computer instructions are executed by a processor, they implement each process of Figure 1 the method embodiment for implementing agent debugging of an agent through the computing power of an intelligent computing center as shown above, and can achieve the same technical effects. To avoid repetition, it will not be elaborated here.

[0196] It should be noted that in this article, the term "including", "comprising" or any other variant thereof is intended to cover non-exclusive inclusion, so that a process, method, article or device including a series of elements not only includes those elements, but also includes other elements not explicitly listed, or further includes elements inherent to such process, method, article or device. Without further limitation, an element defined by the statement "including one..." does not exclude the existence of another identical element in the process, method, article or device including the element.

[0197] Through the description of the above embodiments, those skilled in the art can clearly understand that the above embodiment methods can be implemented by means of software plus a necessary general hardware platform. Of course, they can also be implemented by hardware, but in many cases the former is a better implementation method. Based on such an understanding, the technical solution of the present invention, in essence or the part that contributes to the prior art, can be embodied in the form of a software product. The computer software product is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disc), and includes several instructions for causing a terminal (which can be a mobile phone, a computer, a server, an air conditioner, or a network device, etc.) to execute the methods described in each embodiment of the present invention.

[0198] The embodiments of the present invention have been described above in conjunction with the accompanying drawings. However, the present invention is not limited to the above specific embodiments. The above specific embodiments are merely illustrative rather than restrictive. Under the inspiration of the present invention, those of ordinary skill in the art can also make many forms without departing from the spirit of the present invention and the scope protected by the claims, and all of them fall within the protection scope of the present invention.

Claims

1. A method for implementing intelligent agent debugging intelligent agent through the computing power of intelligent computing center, characterized in that: include: Step S1: The debugging agent receives task information provided by the user through an interactive interface, wherein the task information is used to instruct to debug the debugged object, wherein the debugged object is the debugged agent, or a functional module or tool function of the debugged agent; Step S2: the debugging agent determines the debugging requirements according to the task information, and the debugging requirements include: the debugged object, the debugging environment, the debugging expectations and the test cases; Step S3: the debugging agent determines a debugging method according to the debugging requirement, deploys the debugging environment according to the debugging method, generates running instructions and debugs the debugged object; Step S4: the debugging agent obtains the running information of the debugged object, analyzes the running information, and evaluates whether the debugging requirement is met according to the analysis result; the running information includes at least one of the following: running status, running log, intermediate data, running results, indicator data and resource occupancy information; Step S5: When the debugging requirement is not met, the debugging agent checks the code of the debugged object, modifies the code according to the inspection result, and returns to step S3 until the debugging requirement is met; Step S6: The debugging agent feeds back the debugging results to the user through the interactive interface.

2. The method according to claim 1, characterized in that The functional modules of the debugged intelligent agent include at least one of the following: perception module, thinking chain module, decision module, reflection module 、 Memory module, learning module, tool framework module and necessary framework or system module.

3. The method according to claim 1, characterized in that The step S2 comprises: Step S21: the debugging agent communicates with the user at least once through the interactive interface according to the task information to confirm the debugging requirement.

4. The method according to claim 1, characterized in that: The step S3 comprises: Step S31: The debugging agent determines the debugging method according to the debugging requirements, deploys the debugging environment, generates running instructions and debugs the debugged object according to the debugging method, and the debugging method includes at least one of the following: command line-based debugging, interface-based debugging, web page technology-based debugging or computer vision-based debugging.

5. The method according to claim 1, characterized in that After step S4, the following steps are also included: Step S7: When the debugging requirements are met, the debugging agent stores the debugging process information and the repair process information in the knowledge base of the intelligent computing center. The debugging process information includes: debugging input and output, the operation log, the intermediate data, interface return data, browser feedback, screenshots; the repair process information includes: code before modification, code after modification, and modification record log.

6. The method according to claim 1, characterized in that The debugging agent includes one or more agents, and the multiple agents include at least one of the following: an operating agent, a debugging environment deployment agent, a monitoring agent, a requirement confirmation agent, a code generation agent, a code compilation agent, and an evaluation agent.

7. A device for implementing intelligent agent debugging of intelligent agents through the computing power of an intelligent computing center, characterized in that: include: A task receiving module, used for receiving task information provided by a user through an interactive interface, wherein the task information is used for instructing to debug a debugged object, wherein the debugged object is a debugged intelligent agent, or a functional module or tool function of the debugged intelligent agent; A debugging requirement determination module, used to determine debugging requirements according to the task information, wherein the debugging requirements include: a debugged object, a debugging environment, debugging expectations, and test cases; A deployment and operation module, used to determine a debugging method according to the debugging requirement, deploy the debugging environment according to the debugging method, generate an operation instruction and debug the debugged object; A monitoring and evaluation module, used to obtain the operation information of the debugged object, analyze the operation information, and evaluate whether the debugging requirement is met according to the analysis result; the operation information includes at least one of the following: operation status, operation log, intermediate data, operation result, indicator data and resource occupancy information; A code generation module is used to check the code of the debugged object when the debugging requirement is not met, modify the code according to the inspection result, and trigger the deployment and operation module and the monitoring and evaluation module to continue working until the debugging requirement is met; The feedback module is used to provide debugging results to users through an interactive interface.

8. An electronic device, characterized in that: include: A processor, a memory, and a program stored in the memory and executable on the processor, wherein the program, when executed by the processor, implements the steps of a method for implementing intelligent agent debugging by using the computing power of an intelligent computing center as described in any one of claims 1 to 6.

9. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a computer program, which, when executed by a processor, implements the steps of a method for implementing intelligent agent debugging by using the computing power of an intelligent computing center as described in any one of claims 1 to 6.

10. A computer program product, characterized in that It includes computer instructions, which, when executed by a processor, implement the steps of a method for implementing intelligent agent debugging by using the computing power of an intelligent computing center as described in any one of claims 1 to 6.

Images