Intelligent agent application system for controlling intelligent agent

Abstract

The invention discloses an agent application system for controlling agents, which relates to the technical field of artificial intelligence and comprises the following modules: a first agent, a low-code model fine tuning module, a task evaluation and sample acquisition module, a user feedback module and an iterative optimization module. Based on an open source language large model, performing fine tuning through a data set with a reasoning process, performing fine tuning on a task execution strategy according to user feedback, evaluating task execution accuracy, execution time and resource consumption, and storing high-quality task execution data to a database; collecting and numeralizing user feedback, and optimizing a task execution strategy of the intelligent agent; fine-tuning hyper-parameters of the first intelligent agent through data in a low-code model fine-tuning module database to generate a second intelligent agent; based on the data of the low-code fine tuning module, the execution capability of the agent is continuously improved. The method can adapt to various complex task requirements, and the accuracy and efficiency of task execution and the resource utilization rate are remarkably improved.

Description

Technical Field

[0001] The present invention relates to the field of artificial intelligence technology, and in particular, to an intelligent agent application system for controlling an intelligent agent. Background Art

[0002] With the rapid development of artificial intelligence technology, more and more fields have started to use intelligent agents to perform tasks. Most traditional intelligent agent systems rely on preset rules and static model parameters, and often cannot cope with the constantly changing task requirements in actual applications, resulting in insufficient flexibility and adaptability of the system. Especially during the task execution process, it is difficult to effectively adjust the task path and parameter settings of the intelligent agent according to real-time feedback, thereby reducing the execution efficiency and resource utilization rate.

[0003] In recent years, with the development of deep learning and reinforcement learning technologies, the self-optimization and adaptive capabilities of intelligent agents have been significantly improved. However, there are still some problems in existing intelligent agent systems. First, traditional model optimization usually relies on manually designed optimization algorithms, which are inefficient and cannot quickly adapt to complex and changing task environments. Second, existing systems lack an effective feedback mechanism and are difficult to dynamically adjust the task execution path according to the actual execution situation, resulting in the failure to achieve the best balance among task accuracy, execution time, and resource consumption.

[0004] In addition, current intelligent agent optimization methods mainly focus on single model or fixed parameter adjustment, lacking comprehensive consideration of multiple optimization goals (such as task execution accuracy, execution time, resource consumption, etc.). Especially when facing multi-tasks and complex tasks, the system is often unable to select paths and adjust hyperparameters in real time according to task feedback, thus affecting the overall performance of the system. Summary of the Invention

[0005] The purpose of the present invention is to solve the problems in the background art, and to propose an intelligent agent application system for controlling an intelligent agent.

[0006] To achieve the above purpose, the present invention adopts the following technical solutions:

[0007] An intelligent agent application system for controlling an intelligent agent, comprising:

[0008] A first intelligent agent: obtained by fine-tuning an open-source language large model through a dataset with an inference process, the first intelligent agent self-optimizes the initial model through supervised learning or reinforcement learning, continuously adjusts its task execution path, and optimizes tasks according to execution feedback;

[0009] Low-code Model Fine-tuning Module: Used to fine-tune the first intelligent agent. The low-code model fine-tuning platform receives the inference results of the first intelligent agent during task execution, assists it in optimizing the task execution path, and simultaneously fine-tunes the task execution of the first intelligent agent according to user feedback;

[0010] Task Evaluation and Sample Collection Module: When the first intelligent agent executes different tasks, evaluate its pros and cons according to the task execution results. The evaluation criteria include task execution accuracy, execution time, and resource consumption, and store high-quality task execution data samples in the database of the low-code model fine-tuning platform;

[0011] User Feedback Module: Combine the feedback data generated by the user during task execution. By collecting the user's feedback on the task execution results, input the feedback data and the task execution results into the database of the low-code model fine-tuning module to optimize the task execution strategy of the first intelligent agent;

[0012] Fine-tuning Intelligent Agent Module: The fine-tuning intelligent agent obtains the second intelligent agent by fine-tuning the hyperparameters of the first intelligent agent's task execution according to the data in the database of the low-code model fine-tuning module, thereby improving the task execution ability of the second intelligent agent;

[0013] Iterative Optimization Module: The second intelligent agent further fine-tunes its own task execution path using the data of the low-code model fine-tuning module through repeating the above fine-tuning process to obtain the third intelligent agent, so as to continuously improve the task execution ability of the model.

[0014] Preferably, the low-code model fine-tuning module collects user feedback and converts it into numerical data, where the user's satisfaction is used as a feedback signal; the feedback data is integrated using the weighted average method to obtain the final feedback weighted value F final : F final =α×F accuracy +β×F time +γ×F feedback where, F accuracy is the task accuracy, F time is the task execution time, F feedback is the user feedback value, and α, β, γ are weight coefficients.

[0015] Preferably, the task evaluation and sample collection module evaluates the execution quality of the task according to the feedback of the first intelligent agent's task execution, and screens out high-quality data samples through standards. The high-quality samples are stored in the database of the low-code model fine-tuning module, including: Accuracy Evaluation: For the predicted output of the task, judge the matching degree between it and the expected output; for classification tasks, the accuracy calculation formula is as follows: For regression tasks, the mean square error is used to evaluate the difference between the prediction and the actual value: If the accuracy is higher than the set threshold, the task is considered to be of high quality and meets the sampling standard.

[0016] Preferably, the first agent adopts a reinforcement learning strategy and identifies higher-reward task paths through a feedback reward mechanism; the rewards include task execution accuracy, execution time, and resource consumption metrics.

[0017] Preferably, the first agent further includes: fine-tuning using a supervised learning method with a dataset with an inference process, so that the first agent can perform inference and derivation in specific tasks; during the training process, the first agent compares the task execution result with the expected result and adjusts the model parameters according to the error, thereby optimizing the inference path and improving the task execution accuracy.

[0018] Preferably, the iterative optimization module includes dynamically optimizing the resource consumption of task execution: reducing the computational precision according to the task requirements to reduce resource occupancy; reducing the resource requirements during task execution by adjusting the parallelism and the number of threads of the task; if the task can be processed in parallel, further improving the execution efficiency through asynchronous computing; the resource consumption formula: the optimized resource consumption R optimized and the original resource consumption R original The relationship between them is described by the optimization coefficient β: R optimized = R original ·(1 - β) where β is the resource consumption optimization coefficient, representing the optimization efficiency.

[0019] Preferably, the low-code module further includes generating multiple alternative execution paths. The execution efficiency of the current path is η0, and there are multiple candidate paths, whose execution efficiencies are η1, η2, …, η n , and the optimal path is: η max = max(η1, η2, …, η n ) Select the path η with the maximum efficiency max as the final execution path.

[0020] Preferably, the fine-tuning agent module optimizes the performance of the agent through various adaptive strategies, including: adjusting the learning rate according to the feedback of the execution result; if overfitting occurs in the system, introducing regularization techniques to prevent the model from over-optimizing for certain tasks; the fine-tuning agent module dynamically selects an optimization algorithm according to the task execution situation; if the execution time is too long or the resource consumption is too large, the fine-tuning agent module will adjust the batch size, and a smaller batch size can reduce memory occupancy, thereby accelerating the processing of tasks.

[0021] Preferably, the iterative optimization module further includes: adjusting the task path to reduce the computational complexity for path optimization. The calculation formula: the optimized execution time Toptimized The relationship with the original execution time T original is described by the optimization coefficient α: T optimized = T original ·(1 - α), where α is the optimization coefficient, representing the efficiency of path optimization.

[0022] Preferably, during the iteration process, the iterative optimization module adjusts the hyperparameters of the agent according to the feedback data of the current task execution. Further improving the execution efficiency of the agent includes: according to the error E error of the task execution and the set tolerance error threshold E threshold , adjusting the learning rate; too large a learning rate may lead to overfitting, while too small a learning rate may make the training process too slow; the adjustment formula: where η new is the new learning rate, and η old is the old learning rate.

[0023] The present invention has the following beneficial effects:

[0024] 1. In the present invention,... Through the application of the low-code model fine-tuning module, it is possible to optimize the agent in real time according to the feedback data during the task execution process, avoiding the cumbersome steps of repeatedly modifying the code in the traditional model optimization process, and realizing efficient and flexible task execution path optimization. At the same time, through the task evaluation and sample collection module, high-quality task data is continuously collected, and dynamic fine-tuning is carried out in combination with user feedback, so that the agent can continuously adapt to changing task requirements, ensuring the high efficiency and stability of task execution.

[0025] 2. In the present invention, the system has the characteristic of continuous improvement in task execution ability. Through multiple fine-tuning and optimization, it is possible to continuously identify and improve the unsatisfactory task paths during the execution process. Especially when the resource consumption is too large or the time exceeds the preset standard during the task execution process, it is possible to timely optimize the resources and reselect the path, effectively controlling the occupation of system resources. This continuous optimization ability, combined with the adaptive adjustment of user feedback, ensures the accuracy of task execution and the reasonable utilization of system resources, further enhancing the self-adaptability and task execution quality of the agent. BRIEF DESCRIPTION OF THE DRAWINGS

[0026] Figure 1 is the architecture diagram of an agent application system for controlling an agent proposed by the present invention;

[0027] Figure 2 is the schematic diagram of the multi-round iterative optimization process in the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0028] Next, the technical solutions in the embodiments of the present invention will be clearly and completely described in conjunction with the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all 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.

[0029] As Figure 1 - Figure 2 shown, an intelligent agent application system for controlling an intelligent agent proposed by the present invention.

[0030] In one embodiment, the first intelligent agent is based on an open-source language large model and is fine-tuned through a dataset with an inference process. Specifically, it includes steps such as dataset preparation, task execution, and optimization feedback:

[0031] The first intelligent agent uses an open-source language large model (such as GPT series, BERT, etc.) as the basic model. Through the supervised learning method, the model is fine-tuned using a dataset with an inference process, so that the model can perform inference and derivation in specific tasks.

[0032] For example, the input dataset size is 50,000 task instances with an inference process; the basic model is GPT-4. During the training process, the model compares the task execution results with the expected results and adjusts the model parameters according to the error (such as the error rate is lower than 5%) to optimize the inference path and improve the task execution accuracy.

[0033] The first intelligent agent adopts a reinforcement learning strategy. Through the feedback reward mechanism, the model identifies which task paths can bring higher rewards. The rewards include indicators such as task execution accuracy, execution time, and resource consumption. The model continuously adjusts the task execution path according to these feedbacks and selects the optimal path.

[0034] Feedback reward: Execution accuracy: The matching degree between the task execution result and the expected result reaches 95%.

[0035] Execution time: The task execution time is 3 seconds (the goal is to complete the task within 5 seconds).

[0036] Resource consumption: The computing resource consumption is 40% (a high reward is given when the resource usage is less than 50%).

[0037] When performing a task, the first intelligent agent performs the task according to the fine-tuned model and the optimized inference path. For example, when performing a mathematical reasoning task, the model gradually calculates according to the learned inference rules until the final answer is obtained. During the execution process, the first intelligent agent will monitor the task feedback in real time and dynamically adjust the task execution path according to the feedback. If the execution accuracy of a certain path is low or the execution time is too long, the model will automatically select other paths to optimize the task execution strategy.

[0038] If the accuracy of Path 1 is lower than 90% and the execution time exceeds 10 seconds, the model will automatically switch to Path 2 for execution.

[0039] During the task execution, the first agent will evaluate the task results according to the following criteria:

[0040] Execution accuracy: By calculating the matching degree between the model output and the expected result, if the accuracy reaches the predetermined standard, the task execution effect is excellent.

[0041] Execution time: Record the task execution time, with the goal of completing the task in the shortest time.

[0042] Resource consumption: Monitor the computing resources consumed during the model execution to ensure that the resource consumption is within the predetermined range.

[0043] If the task execution result does not meet the predetermined standard (for example, the accuracy is lower than 90%, the execution time exceeds 10 seconds, or the resource consumption exceeds 80%), the first agent will adjust the task execution path or learning parameters according to the feedback to improve the execution effect of subsequent tasks.

[0044] When the model shows a low accuracy or a long execution time during the task execution, the first agent will automatically trigger the self-optimization mechanism. This mechanism includes the following adjustment methods:

[0045] Path re-selection: According to historical data and task experience, the model will select other alternative paths to improve the task execution efficiency and accuracy.

[0046] If the execution time of Path 1 exceeds the predetermined 5 seconds, the model will automatically select Path 2 with an execution time less than 5 seconds.

[0047] Learning rate adjustment: When a high execution error rate is found during the task execution, the model will automatically reduce the learning rate for more detailed fine-tuning to avoid execution failures caused by too rapid parameter updates.

[0048] During the task execution, the first agent collects task execution data in real time, including execution time, resource consumption, accuracy, etc., and analyzes the data. If a certain task execution path performs poorly, the agent will adjust the execution strategy according to the real-time feedback. In addition, the module also includes incremental learning, inputting the newly obtained task execution data as training data into the model, so that the model can gradually adapt to new task requirements during subsequent task executions and optimize the inference path.

[0049] When the task execution time exceeds the predetermined target by 2 seconds, the module will fine-tune the model according to the new data to shorten the execution time within the target range.

[0050] When the task type changes, the first agent adopts a transfer learning strategy to transfer relevant knowledge from previous similar tasks to accelerate the model's adaptation to the new task. For example, if the task switches from mathematical reasoning to logical reasoning, the model will automatically adjust the reasoning method and utilize the learned reasoning skills to adapt to the new task.

[0051] If the model has learned the mathematical reasoning task, when migrating to the logical reasoning task, the model will adjust the reasoning method according to the existing knowledge to meet the requirements of the new task.

[0052] After each task execution, the user's feedback (such as the accuracy of the task result, the recognition of the reasoning process, etc.) will be collected and fed back to the first agent. Based on the user feedback, the model will further optimize the execution strategy to improve the overall performance of task execution.

[0053] If the user feedback shows that the accuracy of the task result is less than 90%, the model will adjust the reasoning path according to the user feedback to increase the execution accuracy of subsequent tasks to over 95%.

[0054] Through the above implementation steps, the first agent can, based on the open-source large language model, be fine-tuned with a dataset with an inference process, continuously optimize the task execution path, and improve the efficiency and accuracy of task execution. During the execution process, the model can dynamically adjust the task execution strategy according to the execution feedback and continuously optimize its reasoning path based on the user feedback and task evaluation.

[0055] In one embodiment, the low-code model fine-tuning module optimizes the task execution efficiency and accuracy of the model according to the task execution data of the first agent through a feedback mechanism. The working process of this module includes steps such as receiving the task execution result, analyzing the task performance, generating and selecting the optimal execution path, integrating feedback data, and fine-tuning hyperparameters. The specific implementation steps are as follows:

[0056] The low-code model fine-tuning module first receives the task execution result data from the first agent, including:

[0057] Input data features: such as word vectors in text data, pixel matrices in image data, etc.

[0058] Intermediate results during the reasoning process: such as activation values in the middle layer of the neural network, etc.

[0059] Output results: the final reasoning answer or classification result, etc.

[0060] Execution performance metrics: including task execution time, computing resource consumption, memory occupancy, etc.

[0061] Based on these data, the module will conduct preliminary analyses such as resource consumption, accuracy evaluation, and execution time analysis.

[0062] Resource consumption analysis: The resource consumption is calculated through the following formula:

[0063] For each task, the module will evaluate whether the use of computing resources is reasonable to ensure that the resource consumption is controlled within a reasonable range.

[0064] Accuracy evaluation: By comparing the actual output and the expected output of the task, the accuracy of the task is calculated:

[0065] If the accuracy is low, the module will mark this path as the target to be optimized.

[0066] Execution time analysis: Evaluate whether the execution time of the task meets the expectation. If the execution time exceeds the set threshold (e.g., 10 seconds), then this task path will be marked as the target to be optimized.

[0067] During the task execution, the low-code model fine-tuning module traces back the reasoning process of the first agent and gradually evaluates the effects of each execution path. Through the following formula, the efficiency of the task execution is evaluated:

[0068] The module will compare the execution efficiencies under different paths, evaluate the optimal path, and optimize according to the optimal path.

[0069] Based on historical task data, the low-code module generates multiple alternative execution paths. For example, if the execution efficiency of the current path is η0, the low-code module can generate multiple candidate paths, and their efficiencies are η1, η2, …, η n .

[0070] The optimal path is selected through the following formula:

[0071] η max = max(η1, η2, …, η n ) Select the path η with the maximum efficiency max as the final execution path.

[0072] After selecting the optimal path, the module feeds it back to the first agent for task execution.

[0073] The low-code model fine-tuning module will collect user feedback and convert it into numerical data. For example, the user's satisfaction (e.g., "very satisfied" = 1, "average" = 0.5, "dissatisfied" = 0) will be used as the feedback signal. All feedback data will be integrated using the weighted average method to obtain the final feedback weighted value F final :

[0074] F final = α × F accuracy+β×F time +γ×F feedback

[0075] Wherein, F accuracy is the task accuracy, F time is the task execution time, F feedback is the user feedback value, and α, β, and γ are weight coefficients.

[0076] According to the user feedback and the task execution result, the low-code model fine-tuning module optimizes the learning rate and other hyperparameters of the first agent. Assume the current learning rate is λ old , and it is adjusted according to the feedback result as:

[0077] λ new = λ old ×(1 + δF final ) Wherein, δ is the sensitivity factor of the feedback to the learning rate adjustment. If the user feedback is good, F final > 0.8, then increase the learning rate; otherwise, decrease the learning rate.

[0078] The low-code model fine-tuning module also adjusts the hyperparameters of the neural network according to the feedback result, such as:

[0079] Neuron number adjustment: By increasing or decreasing the number of neurons in the hidden layer (such as adding 1 layer of neurons:

[0080] According to the execution situation of the task, decide whether to replace the optimization algorithm, such as switching from SGD to Adam, etc.

[0081] After each task execution, the low-code model fine-tuning module adds the new task execution data (including task input, output, and feedback) to the dataset for subsequent incremental learning. The step size ΔW of each update will be based on the error correction of the current training data and the new samples to ensure that the model does not deviate from the previous learning results during the incremental training process.

[0082] After each fine-tuning, the low-code model fine-tuning module will evaluate the task execution of the first agent. The main evaluation metrics include:

[0083] Task execution time: Ensure that the task execution time meets the set threshold requirements.

[0084] Resource consumption: Monitor the usage of resources such as memory, CPU, and GPU to ensure that the resource consumption is controlled within a reasonable range.

[0085] Fine-tuning effect: Use a standardized evaluation model to judge whether the fine-tuning is successful, including accuracy, execution efficiency, and resource consumption, etc.

[0086] After fine-tuning, the low-code model fine-tuning module saves the updated model to ensure that the new execution strategy is applied in subsequent tasks.

[0087] In one embodiment, the task evaluation and sample collection module evaluates the execution quality of a task based on the feedback of the first agent executing the task, and filters out high-quality data samples through criteria. The high-quality samples are stored in the low-code model fine-tuning module database for subsequent fine-tuning processes, including:

[0088] Accuracy evaluation: For the predicted output of a task, judge the degree of match with the expected output.

[0089] For classification tasks, the accuracy calculation formula is as follows:

[0090] For regression tasks, the mean squared error (MSE) is used to evaluate the difference between the prediction and the actual value: If the accuracy is higher than a set threshold (such as 90%), the task is considered high-quality and meets the sampling criteria.

[0091] Execution time evaluation: The system evaluates the efficiency of a task by the duration of task execution. If the execution time exceeds 10 seconds, the system marks the task as an object to be optimized.

[0092] Execution time = end time - start time. If the execution time exceeds the threshold, the task needs to be optimized.

[0093] Resource consumption evaluation: Monitor the system resources consumed during task execution, such as CPU, memory, etc., and calculate the resource consumption ratio:

[0094] If the resource consumption exceeds 80%, the task is marked as needing further optimization.

[0095] Based on the above evaluation criteria, the module automatically filters out task data that meets the high-quality criteria. The high-quality task data includes but is not limited to the following:

[0096] Task input data: Task inputs of types such as text, images, tables, etc.

[0097] Task output results: Such as classification labels, predicted values, regression results, etc.

[0098] Evaluation metrics: Include task accuracy, execution time, resource consumption, etc.

[0099] The filtered high-quality task samples will be stored in the low-code model fine-tuning platform database for subsequent fine-tuning use. When storing the data, the system will perform real-time archiving and version management to ensure the currency and validity of the data.

[0100] Data storage optimization strategy:

[0101] Data storage limit: Set the database capacity limit, such as 10,000 entries. Once the limit is reached, the system automatically deletes the oldest sample data.

[0102] Priority storage of high-quality data: Only store high-quality samples that meet the standards to avoid unqualified data occupying storage space.

[0103] Sample version management: All data will be timestamped to ensure that the latest valid samples are used for each fine-tuning.

[0104] Task execution example: For example, assume that the first intelligent agent is performing a text classification task. The input of the task is user comment data, and the output is sentiment classification (such as "positive" or "negative"). The execution process of the task evaluation and sample collection module is as follows:

[0105] Task execution: The first intelligent agent receives the text input and classifies it.

[0106] Accuracy evaluation: By comparing the predicted label with the true label, the task accuracy is calculated as 100%.

[0107] Execution time evaluation: The system records the execution time of the task. Assume the execution time is 8 seconds, which meets the high-quality standard.

[0108] Resource consumption evaluation: The system monitors the resource consumption during the task execution. Assume the CPU resource consumption is 70% and the memory consumption is 60%, both of which meet the high-quality standard.

[0109] Data storage: Since the task meets the accuracy, execution time, and resource consumption standards, the module stores information such as the input, output, execution time, and resource consumption of the task in the low-code model fine-tuning platform database.

[0110] For any task with an execution time exceeding 10 seconds or a resource consumption exceeding 80%, the system will automatically mark it as needing optimization and notify the subsequent process for corresponding adjustments. After optimization, the task will be re-evaluated and may be re-stored to ensure the use of optimal data samples in the subsequent fine-tuning process.

[0111] The task evaluation and sample collection module ensures that high-quality task execution data is effectively screened and stored through precise standard evaluation and real-time data storage management. These data will provide strong data support for subsequent fine-tuning, thus continuously optimizing the task execution ability of the intelligent agent.

[0112] In one embodiment, the user feedback module provides support for optimizing the task execution strategy of the intelligent agent by collecting the feedback data of the user during the task execution process and combining it with the original data of the task execution (such as accuracy, execution time, etc.). The main goal of this module is to fine-tune the specific task path or execution strategy through the real-time feedback of the user, so as to achieve personalized and intelligent optimization.

[0113] During the task execution process, the first intelligent agent presents the task result to the user and guides the user to provide feedback according to the nature of the task. The user's feedback includes the following categories:

[0114] Whether the task is successfully completed: The user evaluates whether the task is successfully completed as expected.

[0115] Task execution quality: The user's evaluation of the accuracy, efficiency of the task, and whether the requirements are met.

[0116] Difficulty level during task execution: The user's feedback on the obstacles or challenges encountered during the task execution process.

[0117] Other qualitative feedback: The user's suggestions, expectations for the intelligent agent's execution strategy, or descriptions of abnormal situations.

[0118] The user can provide feedback through various input methods (such as interface buttons, slider ratings, text input, or voice). The feedback data is processed through standardization. For example, the satisfaction is converted into a rating (such as 1 to 5 points), and the task execution quality is evaluated (low / medium / high), so that this feedback can be processed and analyzed together with other performance indicators of the task execution (such as accuracy, execution time, resource consumption).

[0119] The user feedback data will be combined with the task execution data (such as task input, execution time, resource consumption, etc.) to form a unified data set. The integrated feedback data and the task execution results are stored in the low-code model fine-tuning module database together. The feedback content of each task will be archived as the basis for continuous optimization.

[0120] Based on the user feedback, the low-code model fine-tuning module will optimize the task execution strategy of the intelligent agent. The specific optimization methods include:

[0121] Task path optimization: If the user feedback indicates that the task path is too complex or lengthy, the system will analyze the user's feedback and adjust the decision-making process of the intelligent agent to improve the simplicity and efficiency of the task execution.

[0122] Result matching optimization: When the user feedback indicates that the task execution result does not meet the expectations, the system analyzes the reasons for the failure (such as low accuracy, large result deviation) to adjust the task execution strategy or model parameters to improve the matching degree of the task result.

[0123] Efficient Path Priority Application: Through long-term accumulated user feedback, the system can identify those execution paths and strategies that receive high scores and prioritize their application to new tasks to improve execution quality and efficiency.

[0124] The user feedback module and the task evaluation module form a closed loop. By continuously collecting and analyzing user feedback, the agent can continuously adjust according to the user's needs and expectations. The system will automatically mark the execution paths that users frequently feedback as unsatisfactory (for example, some task paths perform poorly multiple times), and optimize these paths through the low-code model fine-tuning module.

[0125] Based on the accumulated user feedback, the system will automatically generate feedback reports. These reports provide in-depth user needs analysis and help the development team identify the weak links and optimization opportunities of the system. The report content includes:

[0126] User Satisfaction Score: An overall evaluation of the task execution process, reflecting the user's acceptance of the execution result.

[0127] Analysis of Common Problem Points: Analyze the frequent problems in user feedback to identify possible bottlenecks or optimization directions.

[0128] Optimization Suggestions: Based on user feedback, propose specific improvement measures or optimization directions to provide guidance for subsequent task execution adjustment and iteration.

[0129] For example, assume that the first agent executes a text classification task, the task input is the user comment, and the output is the sentiment classification. After the task execution, the user feedback module performs the following operations:

[0130] Feedback Collection: The user feedback that the task execution is highly accurate, there are no obstacles in the process, but hopes that the task execution speed can be faster.

[0131] Data Integration: Integrate the user's feedback with the task execution data (such as execution time of 8 seconds and resource consumption of 70%).

[0132] Strategy Optimization: The system identifies the user's need for execution speed, adjusts the task path, tries to reduce redundant operations, and optimizes the task execution strategy.

[0133] Report Generation: Generate a feedback report on the task execution, analyze the task execution efficiency and accuracy, and provide suggestions for the next step of optimization.

[0134] In one embodiment, the fine-tuning agent module dynamically adjusts the model parameters of the agent by receiving real-time task execution feedback, enabling the agent to continuously optimize its accuracy, execution efficiency, and resource consumption when executing specific tasks, thereby improving the overall performance of task execution.

[0135] Receive and analyze the feedback data generated during task execution. This data includes:

[0136] Execution result data: Reflect whether the task is successfully executed (such as "correct" or "wrong").

[0137] Execution time data: Record the time required to complete the task.

[0138] Resource consumption data: Record the resource usage during task execution, especially the CPU and memory occupancy.

[0139] User feedback data: Integrate data based on the user's feedback on the task (such as the evaluation of task accuracy or response time).

[0140] These feedback data are transmitted to the database of the fine-tuning agent module for subsequent analysis and optimization decisions.

[0141] The fine-tuning agent module first evaluates the collected task execution data to determine whether it meets the set performance criteria. The evaluation criteria include:

[0142] Execution accuracy (Accuracy): If the execution result of the task is "correct", the accuracy is qualified; otherwise, it is unqualified.

[0143] Execution time (Time): Evaluate whether the execution time of the task exceeds the set threshold (such as 10 seconds).

[0144] Resource consumption (Resources): Whether the CPU and memory resources used during task execution exceed the set upper limit.

[0145] If the task execution does not meet the standard, the fine-tuning agent module will start the self-optimization process.

[0146] The fine-tuning agent module optimizes the performance of the agent through various adaptive strategies:

[0147] Learning rate adjustment (Learning Rate): Adjust the learning rate according to the feedback of the execution result (such as accuracy and time). For example, when the accuracy is low, reduce the learning rate to avoid overfitting; when the task execution is smooth, appropriately increase the learning rate to accelerate model convergence.

[0148] Regularization: If the system shows overfitting (for example, high accuracy but poor performance in new tasks), the fine-tuning agent module will introduce regularization techniques (such as L2 regularization) to prevent the model from over-optimizing for certain tasks and maintain good generalization ability.

[0149] Optimization Algorithm Selection: The fine-tuning agent module dynamically selects the most suitable optimization algorithm according to the task execution situation. For example, if the execution time is too long or the computational complexity is high, a more efficient optimization algorithm (such as Adam) is adopted to accelerate the model convergence.

[0150] Batch Size Adjustment: If the execution time is too long or the resource consumption is too large, the fine-tuning agent module will adjust the batch size. A smaller batch size can reduce the memory occupation, thus accelerating the task processing.

[0151] After each optimization, the fine-tuning agent module will retrain the model with new data samples to complete self-optimization. The optimized model will be verified in multiple standardized tasks to test its accuracy, execution time, and resource consumption. If the performance of the optimized agent is better, it will replace the original agent and be put into actual task execution.

[0152] The fine-tuning agent module will be evaluated after optimization, mainly checking:

[0153] Task Execution Accuracy: If the accuracy rate of the optimized model in the test task reaches more than 90%, the optimization is considered effective.

[0154] Execution Time: If the execution time of the task is less than the set threshold (such as 10 seconds), the optimization is considered effective.

[0155] Resource Consumption: If the CPU and memory resource consumption during task execution is lower than the set threshold (80% CPU, 70% memory), the optimization is considered effective.

[0156] Among them, the self-optimization of the fine-tuning agent module is a continuous process. New task execution data will be continuously fed back into the module to provide data support for subsequent optimization. Each round of optimization not only improves the model's performance on the current task but also accumulates experience for future task execution, further enhancing the agent's capabilities.

[0157] Through continuous optimization and adaptive adjustment, the fine-tuning agent module can dynamically improve the agent's task execution ability according to real-time feedback, continuously enhancing accuracy, execution efficiency, and resource consumption control, ensuring that the agent can always complete tasks efficiently.

[0158] In one embodiment, the iterative optimization module performs multi-round iterative optimization to enhance the agent's task execution ability. By gradually analyzing the feedback of task execution data (such as accuracy, execution time, resource consumption, etc.), the task execution path and model hyperparameters are optimized to ensure the efficiency, accuracy, and rationality of resource occupation of task execution.

[0159] Receive task execution feedback data from the database of the low-code model fine-tuning module, specifically including execution accuracy, execution time, resource consumption, etc.

[0160] At the initial stage of each round of iterative optimization, the iterative optimization module uses the current hyperparameters of the second agent (such as learning rate, batch size, optimization algorithm, etc.) as the base parameters to ensure a smooth transition of the optimization process.

[0161] By analyzing the task execution path, eliminate redundant or inefficient steps, optimize the task path, thereby improving the execution efficiency and shortening the task execution time. The specific implementation steps are as follows:

[0162] By tracing back the task execution process, identify possible redundant calculation steps. For example, some data preprocessing steps may be redundant, or some calculation algorithms can be replaced with more efficient ones.

[0163] Adjust the task path, reduce the computational complexity for path optimization, and improve the execution speed.

[0164] Calculation formula: The optimized execution time T optimized and the original execution time T original The relationship between them is described by the optimization coefficient α: T optimized = T original ·(1 - α) where α is the optimization coefficient, representing the efficiency of path optimization.

[0165] During the iteration process, according to the feedback data of the current task execution, the iterative optimization module adjusts the hyperparameters of the agent (such as learning rate, batch size, regularization coefficient, etc.) to further improve the execution efficiency of the agent:

[0166] Learning rate adjustment: According to the error E error of the task execution and the set tolerance error threshold E threshold , adjust the learning rate. If the learning rate is too large, it will lead to overfitting, and if it is too small, the training process may be too slow.

[0167] Adjustment formula: where η new is the new learning rate, and η old is the old learning rate.

[0168] Batch size adjustment: Adjust the batch size according to the resource consumption and computational requirements during task execution to ensure that each training does not overly occupy memory resources and can guarantee sufficient training effects.

[0169] The resource consumption of the agent is an important aspect in task execution optimization. Especially when executing complex tasks, there may be excessive CPU or memory consumption. Therefore, the iterative optimization module will perform dynamic optimization on the resource consumption of task execution:

[0170] Adjust the calculation precision: According to the task requirements, reduce the calculation precision (e.g., from floating-point precision to fixed-point precision) to reduce resource consumption.

[0171] Optimize the parallelism: By adjusting the parallelism of tasks, the number of threads, etc., reduce the resource requirements during task execution.

[0172] Asynchronous calculation: If the tasks can be processed in parallel, further improve the execution efficiency through asynchronous calculation.

[0173] Resource consumption formula: The optimized resource consumption R optimized and the original resource consumption R original The relationship between them is described by the optimization coefficient β: R optimized = R original ·(1 - β) where β is the resource consumption optimization coefficient, representing the optimization efficiency.

[0174] To ensure that each optimization brings an actual improvement, the iterative optimization module sets a maximum number of iterations N max and stopping conditions. The stopping conditions include:

[0175] Execution accuracy stability: If after multiple rounds of iteration, the execution accuracy reaches a preset threshold (e.g., 95%) and there is no further improvement, stop the optimization.

[0176] Resource consumption meets the requirements: When the resource consumption of the system (such as CPU occupancy below 70%) reaches the preset standard, the optimization can be stopped.

[0177] The iterative optimization module will continue with subsequent optimizations based on the results of each round of optimization to generate a new third intelligent agent. Each round of optimization is adjusted based on the previous feedback data, including:

[0178] Continue to optimize the task path. Dynamically adjust hyperparameters (such as learning rate, batch size, regularization coefficient). Further reduce resource consumption. Through multiple rounds of optimization, the final third intelligent agent performs excellently in the following aspects:

[0179] Execution accuracy: Exceed 95% accuracy, reaching or exceeding the predetermined standard.

[0180] Execution time: Compared with the initial version, the execution time is significantly reduced, and the system response speed is faster.

[0181] Resource consumption: Resource consumption is effectively controlled to ensure reasonable allocation of system resources and avoid excessive consumption.

[0182] When the iterative optimization module generates an excellent third agent, this agent will be put into actual application to perform tasks. If it is still found that there are parts that need further optimization during actual task execution, the iterative optimization module will continue to make corresponding adjustments and optimizations.

[0183] The optimization process of the iterative optimization module is a continuous and dynamic loop process. Even after the final version of the agent is deployed, if new problems (such as performance bottlenecks, resource consumption problems, etc.) occur during task execution, the iterative optimization module will continue to optimize according to the feedback data to generate a new version of the agent, ensuring that the system always maintains high performance.

[0184] Through multiple rounds of feedback and optimization, the iterative optimization module continuously adjusts the agent using task execution data, optimizes the task execution path, hyperparameters, and resource consumption, ensuring that the agent reaches the optimal state in multiple aspects, thereby achieving the ability to execute tasks efficiently, accurately, and in a resource-friendly manner.

[0185] Although the embodiments of the present invention have been shown and described, for those of ordinary skill in the art, it can be understood that various changes, modifications, substitutions, and variations can be made to these embodiments without departing from the principles and spirit of the present invention. The scope of the present invention is defined by the appended claims and their equivalents.

Claims

1. An intelligent agent application system for controlling an intelligent agent, characterized in that: include: First agent: The first agent is based on an open source language large model and is obtained by fine-tuning a data set with a reasoning process, wherein the data set contains historical task execution data for different tasks, and the data set has labeled data with reasoning capabilities; the first agent self-optimizes the initial model through supervised learning and reinforcement learning, and in the process of executing tasks, continuously adjusts its task execution path according to real-time feedback of the task, and optimizes the task processing strategy according to the execution results, wherein the execution feedback includes the success rate of the task, execution time, resource consumption and user feedback; Low-code model fine-tuning module: The low-code model fine-tuning module receives the reasoning results of the first agent during the task execution process, identifies potential optimization points in the task path, and assists it in optimizing the task execution path; the low-code platform further adjusts the task execution results based on user feedback and optimizes the execution strategy of the first agent under different tasks; Task evaluation and sample collection module: evaluates the performance of different tasks by the first agent, with evaluation criteria including task execution accuracy, task execution time, resource consumption and reliability of task completion, and stores high-quality task execution result data samples in the low-code model fine-tuning platform database; User feedback module: In combination with the feedback data generated by users during the task execution process, by collecting users' feedback on the task execution results, the feedback data and the task execution results are input into the low-code model fine-tuning module database to optimize the task execution strategy of the first agent, and make real-time adjustments based on user feedback to optimize the task execution strategy of the first agent; Fine-tuning agent module: the fine-tuning agent obtains the second agent by fine-tuning the hyperparameters of the first agent for task execution according to the data in the low-code model fine-tuning module database. The fine-tuning process includes optimizing the key parameters in the task execution path, including the learning rate, batch size, and calculation accuracy. Iterative optimization module: The second agent repeats the above fine-tuning process and uses the data from the low-code model fine-tuning module to further fine-tune its own task execution path to obtain the third agent, so as to achieve continuous improvement of the model's task execution capabilities.

2. The intelligent agent application system for controlling an intelligent agent as claimed in claim 1, characterized in that: The low-code model fine-tuning module collects user feedback and converts it into numerical data, with user satisfaction as the feedback signal; the feedback data is integrated using the weighted average method to obtain the final feedback weighted value F final :F final =α×F accuracy +β×F time +γ×F feedback Among them, F accuracy is the task accuracy, F time is the task execution time, F feedback is the user feedback value, and α, β, γ are weight coefficients.

3. The intelligent agent application system for controlling an intelligent agent as claimed in claim 1, characterized in that: The task evaluation and sample collection module evaluates the execution quality of the task based on the feedback of the first agent performing the task, and selects high-quality data samples according to the standards. The high-quality samples are stored in the low-code model fine-tuning module database, including: Accuracy evaluation: for the predicted output of the task, judge the match between it and the expected output; for classification tasks, the accuracy calculation formula is as follows: For regression tasks, the mean squared error is used to evaluate the difference between the prediction and the actual value: If the accuracy is above the set threshold, the task is considered to be of high quality and meets the sampling criteria.

4. The intelligent agent application system for controlling an intelligent agent as claimed in claim 1, characterized in that: The first intelligent agent adopts a reinforcement learning strategy to identify a higher reward task path through a feedback reward mechanism; the reward includes task execution accuracy, execution time and resource consumption indicators.

5. The intelligent agent application system for controlling an intelligent agent as claimed in claim 1, characterized in that: The first intelligent agent further includes: fine-tuning using a data set with a reasoning process through a supervised learning method, so that the first intelligent agent can perform reasoning and deduction in a specific task; during the training process, the first intelligent agent compares the task execution results with the expected results, and adjusts the model parameters according to the error, thereby optimizing the reasoning path and improving the accuracy of task execution.

6. The intelligent agent application system for controlling an intelligent agent as claimed in claim 1, characterized in that: The iterative optimization module includes dynamic optimization of resource consumption of task execution: according to task requirements, the calculation accuracy is reduced to reduce resource occupation; by adjusting the parallelism and number of threads of the task, the resource requirements during task execution are reduced; if the task can be processed in parallel, the execution efficiency is further improved through asynchronous calculation; the resource consumption formula is: the optimized resource consumption R optimized The original resource consumption R original The relationship between is described by the optimization coefficient β: optimized =R original (1-β) where β is the resource consumption optimization coefficient, representing the efficiency of optimization.

7. The intelligent agent application system for controlling an intelligent agent as claimed in claim 1, characterized in that: The low-code module further includes generating multiple alternative execution paths, the execution efficiency of the current path is η0, and multiple candidate paths, whose execution efficiencies are η1, η2, ..., η n , the optimal path is: η max =max(η1,η2,…,η n ) Select the path with the highest efficiency η max as the final execution path.

8. The intelligent agent application system for controlling an intelligent agent as claimed in claim 1, characterized in that: The fine-tuning agent module optimizes the performance of the agent through a variety of adaptive strategies, including: adjusting the learning rate based on feedback from the execution results; if the system overfits, introducing regularization technology to prevent the model from over-optimizing certain tasks; the fine-tuning agent module dynamically selects the optimization algorithm based on the task execution status; if the execution time is too long or the resource consumption is too large, the fine-tuning agent module will adjust the batch size. A smaller batch size can reduce memory usage, thereby speeding up task processing.

9. The intelligent agent application system for controlling an intelligent agent as claimed in claim 1, characterized in that: The iterative optimization module further includes: adjusting the task path to reduce the computational complexity for path optimization, and the calculation formula is: the optimized execution time T optimized Compared with the original execution time T original The relationship between is described by the optimization coefficient α: optimized =T original (1-α) where α is the optimization coefficient, representing the efficiency of path optimization.

10. The intelligent agent application system for controlling an intelligent agent according to claim 1, characterized in that: During the iteration process, the iterative optimization module adjusts the hyper parameters of the agent according to the feedback data of the current task execution to further improve the execution efficiency of the agent, including: error and the set tolerance error threshold E threshold , adjust the learning rate; too large a learning rate will lead to overfitting, while too small a learning rate may make the training process too slow; adjust the formula: Among them, η new is the new learning rate, η old is the old learning rate.

Images