Complex problem processing method and device based on evolutionary agent, equipment and storage medium

Abstract

The invention provides a complex problem processing method and device based on an evolutionary agent, equipment and a storage medium, and relates to the technical field of artificial intelligence such as large models, agents and evolutionary algorithms. The method comprises the steps of determining a task demand and a current evolution round of a to-be-processed complex problem, and executing an evolution solving step: based on the task demand and historical evolution experience summary, determining a multi-stage improvement strategy of the current evolution round compared with a previous evolution round; generating multi-stage sub-tasks for processing the complex problem to be processed based on the multi-stage improvement strategy, and executing the sub-tasks in all stages in sequence to obtain a current solution; in response to the situation that the current solution does not meet the task demand, generating an evolution experience corresponding to the current evolution round and updating a historical evolution experience summary based on the multi-stage improvement strategy and the actual satisfaction degree of the current solution to the task demand; and taking the next evolutionary round as a new current evolutionary round, and repeatedly executing the evolutionary solving step until a target solution meeting the task requirement is obtained. And the evolution efficiency is improved.

Description

Technical Field

[0001] This disclosure relates to the field of data processing technology, specifically to the field of artificial intelligence technology such as large models, intelligent agents, and evolutionary algorithms, and particularly to a method, apparatus, electronic device, computer-readable storage medium, and computer program product for handling complex problems based on evolutionary intelligent agents. Background Technology

[0002] With the deep application of artificial intelligence technology in scenarios such as complex task optimization and automatic algorithm iteration, traditional algorithm evolution schemes that rely on manual design or single-mode generation are gradually revealing problems such as low generation efficiency, high cost, and insufficient stability of effects.

[0003] Furthermore, as hardware capabilities continue to evolve, software also requires continuous algorithm optimization to maximize hardware performance. Therefore, developing intelligent agents capable of self-evolution and adapting to environmental changes is of paramount importance. Summary of the Invention

[0004] This disclosure presents a method, apparatus, electronic device, computer-readable storage medium, and computer program product for handling complex problems based on evolutionary intelligent agents.

[0005] In a first aspect, embodiments of this disclosure propose a method for handling complex problems based on evolutionary agents, comprising: determining the task requirements and current evolutionary round of the complex problem to be handled, and executing evolutionary solution steps: determining a multi-stage improvement strategy for the current evolutionary round compared to the previous evolutionary round based on the task requirements and a summary of historical evolutionary experience, wherein the summary of historical evolutionary experience is obtained by summarizing different evolutionary experiences generated from different historical solutions in different historical evolutionary rounds; generating multi-stage sub-tasks for handling the complex problem to be handled based on the multi-stage improvement strategy, and sequentially executing each stage sub-task to obtain the current solution; in response to the current solution not meeting the task requirements, generating evolutionary experience with evolutionary orientation corresponding to the current evolutionary round based on the multi-stage improvement strategy and the actual degree to which the current solution meets the task requirements; and updating the summary of historical evolutionary experience using the evolutionary experience of the current evolutionary round. The next evolutionary round is taken as the new current evolutionary round, and the evolutionary solution steps are repeated until the target solution that meets the task requirements is obtained.

[0006] Secondly, embodiments of this disclosure propose a complex problem processing apparatus based on an evolutionary agent, comprising: an evolutionary solving unit configured to determine the task requirements and current evolutionary round of the complex problem to be processed, and to execute the following evolutionary solving steps: based on the task requirements and a summary of historical evolutionary experience, determining a multi-stage improvement strategy for the current evolutionary round compared to the previous evolutionary round, wherein the summary of historical evolutionary experience is obtained by summarizing different evolutionary experiences generated from different historical solutions in different historical evolutionary rounds; generating multi-stage sub-tasks for processing the complex problem to be processed based on the multi-stage improvement strategy, and sequentially executing each stage sub-task to obtain the current solution; in response to the current solution not meeting the task requirements, generating evolutionary experience with evolutionary orientation corresponding to the current evolutionary round based on the multi-stage improvement strategy and the actual degree to which the current solution meets the task requirements; updating the summary of historical evolutionary experience using the evolutionary experience of the current evolutionary round; and a repeat execution unit configured to take the next evolutionary round as the new current evolutionary round and repeatedly execute the evolutionary solving steps until a target solution that meets the task requirements is obtained.

[0007] Thirdly, embodiments of this disclosure provide an electronic device comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to implement the complex problem-solving method based on evolutionary agents as described in the first aspect.

[0008] Fourthly, embodiments of this disclosure provide a non-transitory computer-readable storage medium storing computer instructions that enable a computer to implement the complex problem-solving method based on evolutionary intelligent agents as described in the first aspect when executed.

[0009] Fifthly, embodiments of this disclosure provide a computer program product including a computer program that, when executed by a processor, can implement the steps of the complex problem-solving method based on evolutionary intelligent agents as described in the first aspect.

[0010] The complex problem-solving scheme based on evolutionary agents disclosed herein achieves automated and evolutionary solving of complex problems through a closed-loop process of "task requirements - historical evolutionary experience summary - multi-stage improvement strategy - multi-stage sub-task generation and execution - evolutionary experience generation and update - iterative solution": First, based on the current task requirements and the evolutionary experience summary of different historical solutions, a multi-stage improvement strategy compared to the previous round is automatically determined, replacing traditional manual intervention and avoiding the lag of subjective judgment; then, the complex problem is decomposed into multi-stage sub-tasks that can be executed step by step and executed sequentially to obtain the current solution, improving the structure and controllability of the solution process; if the current solution does not meet the task requirements, experience containing evolutionary direction is generated based on the multi-stage improvement strategy and the actual degree of satisfaction of the current solution, and the historical evolutionary experience summary is updated, realizing the systematic accumulation and reuse of past successful experiences and avoiding starting from scratch in each round of improvement; finally, by iteratively executing the above steps, continuous iterative optimization is carried out until the target solution that meets the task requirements is obtained, realizing dynamic improvement of model performance and effectively dealing with the multi-dimensional requirements of complex tasks. This solution can automatically adapt to changes in task requirements without human intervention. Through the accumulation of historical experience and dynamic optimization, it significantly improves the efficiency, accuracy, and evolutionary iteration efficiency of solving complex problems.

[0011] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of this disclosure, nor is it intended to limit the scope of this disclosure. Other features of this disclosure will become readily apparent from the following description. Attached Figure Description

[0012] Other features, objects, and advantages of this disclosure will become more apparent from the following detailed description of non-limiting embodiments with reference to the accompanying drawings: Figure 1 This is an exemplary system architecture to which this disclosure can be applied; Figure 2 A flowchart illustrating a complex problem-solving method based on evolutionary agents provided in this disclosure embodiment; Figure 3 A flowchart illustrating a method for determining the current solution based on an improved strategy, provided in this embodiment of the disclosure; Figure 4 A flowchart illustrating a method for processing personalized needs provided in this embodiment of the disclosure; Figure 5 A flowchart of a hierarchical memory storage method provided in this disclosure embodiment; Figure 6 A flowchart illustrating a method for determining the current parent solution based on an improvement strategy, provided in this embodiment of the disclosure; Figure 7 A flowchart illustrating a method for generating evolutionary experience provided in this embodiment of the disclosure; Figures 8-1 to 8-7 All of these are schematic diagrams of the structural process in specific application scenarios provided in the embodiments of this disclosure; Figure 9 A structural block diagram of a complex problem processing device based on an evolutionary intelligent agent provided in this disclosure embodiment; Figure 10 This is a schematic diagram of the structure of an electronic device suitable for executing a complex problem-solving method based on an evolutionary agent, provided as an embodiment of the present disclosure. Detailed Implementation

[0013] The exemplary embodiments of this disclosure are described below with reference to the accompanying drawings, including various details of the embodiments to aid understanding; these should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of this disclosure. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description. It should be noted that, unless otherwise specified, the embodiments and features described in this disclosure can be combined with each other.

[0014] The collection, storage, use, processing, transmission, provision, and disclosure of user personal information involved in the technical solution disclosed herein comply with the provisions of relevant laws and regulations and do not violate public order and good morals.

[0015] Figure 1 An exemplary system architecture 100 is shown, to which embodiments of the complex problem-solving methods, apparatuses, electronic devices, and computer-readable storage media based on evolutionary agents of this disclosure can be applied.

[0016] like Figure 1 As shown, system architecture 100 may include terminal devices 101, 102, and 103, a network 104, and a server 105. Network 104 serves as the medium for providing communication links between terminal devices 101, 102, and 103 and server 105. Network 104 may include various connection types, such as wired or wireless communication links, or fiber optic cables, etc.

[0017] Users can use terminal devices 101, 102, and 103 to interact with server 105 via network 104 to receive or send messages, etc. Various applications for enabling information communication between the terminal devices 101, 102, and 103 and server 105 can be installed. These applications include problem-solving applications, evolutionary intelligent agent framework applications, and instant messaging applications.

[0018] Terminal devices 101, 102, and 103 and server 105 can be either hardware or software. When terminal devices 101, 102, and 103 are hardware, they can be various electronic devices with displays, including but not limited to smartphones, tablets, laptops, and desktop computers. When terminal devices 101, 102, and 103 are software, they can be installed in the aforementioned electronic devices, and can be implemented as multiple software programs or software modules, or as a single software program or software module; no specific limitation is made here. When server 105 is hardware, it can be implemented as a distributed server cluster composed of multiple servers, or as a single server. When server 105 is software, it can be implemented as multiple software programs or software modules, or as a single software program or software module; no specific limitation is made here.

[0019] Server 105 can provide various services through its built-in applications. Taking a problem-solving application using an evolutionary agent framework as an example, when running this application, server 105 can achieve the following: First, it receives the problem to be processed from terminal devices 101, 102, and 103 via network 104. Then, it determines the task requirements and current evolutionary stage of the complex problem to be processed, and executes the evolutionary solution steps: Based on the task requirements and historical evolutionary experience, it determines a multi-stage improvement strategy for the current evolutionary stage compared to the previous evolutionary stage. This historical evolutionary experience summary is based on different historical solutions from different historical evolutionary stages. The process involves summarizing different evolutionary experiences to obtain the solution. Next, based on this multi-stage improvement strategy, multi-stage sub-tasks are generated to handle the complex problem, and each sub-task is executed sequentially to obtain the current solution. Then, in response to the current solution not meeting the task requirements, evolutionary experience with evolutionary direction corresponding to the current evolutionary round is generated based on the multi-stage improvement strategy and the actual degree to which the current solution meets the task requirements. Next, the historical evolutionary experience summary is updated using the evolutionary experience corresponding to the current evolutionary round. Finally, the next evolutionary round is used as the new current evolutionary round, and the evolutionary solution steps are repeated until the target solution that meets the task requirements is obtained.

[0020] Furthermore, the server 105 can return the calculated target solution to the terminal devices 101, 102, and 103 via the network 104.

[0021] It should be noted that, in addition to being temporarily obtained from terminal devices 101, 102, and 103 via network 104, complex problems to be processed can also be pre-stored locally on server 105 through various means. Therefore, when server 105 detects that this data is already stored locally (e.g., when starting to process previously stored tasks), it can choose to retrieve this data directly from the local storage. In this case, the exemplary system architecture 100 may also exclude terminal devices 101, 102, and 103 and network 104.

[0022] Since using the evolutionary agent framework to handle complex problems requires significant computing resources and power, the complex problem-solving methods based on evolutionary agents provided in the subsequent embodiments of this disclosure are generally executed by a server 105 with strong computing power and abundant computing resources. Correspondingly, the complex problem-solving device based on evolutionary agents is also generally located within the server 105. However, it should also be noted that when terminal devices 101, 102, and 103 also possess sufficient computing power and resources, they can also perform the aforementioned calculations performed by the server 105 through the problem-solving applications installed on them, thereby outputting the same results as the server 105. Especially when multiple terminal devices with different computing capabilities exist simultaneously, but the problem-solving application determines that its terminal device has strong computing power and abundant remaining computing resources, it can allow the terminal device to perform the aforementioned calculations, thereby appropriately reducing the computing pressure on the server 105. Accordingly, the complex problem-solving device based on evolutionary agents can also be located within terminal devices 101, 102, and 103. In this case, the exemplary system architecture 100 may also exclude the server 105 and the network 104.

[0023] It should be understood that Figure 1 The number of terminal devices, networks, and servers shown is merely illustrative. Depending on implementation needs, any number of terminal devices, networks, and servers can be included.

[0024] Please refer to Figure 2 , Figure 2 A flowchart of a complex problem-solving method based on evolutionary agents provided in this disclosure embodiment, wherein process 200 includes the following steps: Step 201: Determine the task requirements and current evolutionary round of the complex problem to be addressed, and execute the evolutionary solution steps; This step is intended for the implementation of complex problem-solving methods based on evolutionary agents (e.g., Figure 1The server 105 shown or any problem-solving application installed on it determines the task requirements of the problem to be solved and the current evolutionary round, so as to execute the preset evolutionary solution steps for the current evolutionary round (corresponding to step 202, which includes steps 2021 to 2024 below). This step serves as the foundation for initiating the evolutionary solution, and its core function is to provide a clear goal orientation and progress tracking benchmark for each subsequent evolutionary round, ensuring that the evolutionary process always revolves around the actual needs of the system or user.

[0025] Among them, the complex problems to be addressed are mostly machine learning tasks such as high-dimensional data classification and dynamic environment prediction. Their complexity is reflected in two aspects: First, the multidimensionality of the requirements, which need to simultaneously meet mutually constraining indicators such as accuracy, training time, and model size (e.g., XX flower classification requires "accuracy ≥ 95%, training time ≤ 1 hour, model size ≤ 100MB"). Single optimization may lead to the deterioration of other indicators. Second, the dynamic nature of the problems, which may change over time (e.g., initially pursuing accuracy, and later adding requirements for model interpretability), requiring continuous adjustment of strategies. These problems cannot be solved by traditional "one-time modeling" and need to be gradually satisfied through multiple rounds of evolutionary iteration. The task requirements are the specific quantitative goals of the problems to be addressed and serve as the "anchor points" for evolution. It transforms abstract requirements into measurable metrics (e.g., "high accuracy" becomes "accuracy ≥ 95%", "fast training" becomes "training time ≤ 1 hour"). When determining these metrics, user expectations (e.g., business requirements of "response time ≤ 1 second"), problem characteristics (e.g., model size affecting deployment costs in image classification), and constraints (e.g., computational resource limitations) must be considered. The multidimensional nature of task requirements determines the goal-oriented nature of evolutionary solutions; each round must balance multiple metrics rather than pursuing a single objective. The current evolutionary round serves as a tracking marker for optimization progress (e.g., first round, second round), and its functions include: distinguishing optimization stages (e.g., the first round attempts feature engineering, the second round adjusts model parameters), avoiding infinite loops (setting a maximum round limit, e.g., a maximum of 10 rounds), and serving as a vehicle for experience accumulation (the experience gained in each round is used for subsequent strategy adjustments). For example, the experience from the first round, "feature engineering effectively improves accuracy," will guide the second round to continue optimizing feature engineering or adjusting relevant parameters.

[0026] Taking the XX flower classification task as an example, the problem to be solved can be "to build a classification model with high accuracy and low training time", and the task requirements can be "accuracy ≥ 95%, training time ≤ 1 hour, model size ≤ 100MB". The current round is the first round.

[0027] Step 2021: Based on task requirements and historical evolutionary experience, determine the improvement strategy for the current evolutionary round compared to the previous evolutionary round; This step aims to have the aforementioned implementing entity determine the improvement strategy for the current evolutionary round compared to the previous evolutionary round, based on task requirements and historical evolutionary experience. This historical evolutionary experience summary is obtained by summarizing the different evolutionary experiences generated from different historical solutions in different historical evolutionary rounds. In other words, the purpose is to adjust the evolutionary direction by reusing past evolutionary experience and combining it with the specific goals of the current task, so as to avoid repeated and ineffective exploration.

[0028] Among these, the summary of historical evolutionary experience is the accumulation of past rounds. For example, in the previous round, PCA dimensionality reduction improved accuracy but the model was too large, or feature engineering was effective but parameter settings caused time limits to be exceeded. These experiences record "which practices were effective" and "which caused problems," serving as the basis for improvement. The improvement strategy is the product of the combination of the two, answering "what needs to be changed in the current round" and "how to change it." For example, if the model size exceeded the limit in the previous round because the random forest parameters were set too densely, the current round needs to adjust the parameters while maintaining the previously effective PCA (Principal Components Analysis) dimensionality reduction to avoid a decrease in accuracy.

[0029] Taking flower classification as an example, suppose the strategy in the previous round (round 1) was "PCA dimensionality reduction + random forest (n_estimators=100)", resulting in an accuracy of 94% (1% short of the target), a model size of 120MB (20MB over the limit), and a training time of 50 minutes (meeting the requirements). The historical experience summary would record: "PCA dimensionality reduction effectively improved accuracy (from 90% to 94%), but the random forest parameters caused the model to be too large." The task requirement for the current round (round 2) is still "accuracy ≥ 95%, model size ≤ 100MB". Based on historical experience, the improved strategy would be: "Maintain PCA dimensionality reduction to maintain accuracy, reduce the random forest's n_estimators from 100 to 50 to reduce the model size, and increase the tree depth (max_depth=5) to try to improve accuracy to 95%." This strategy not only builds on the success of the previous round (PCA dimensionality reduction) but also corrects the problems of the previous round (the model was too large). At the same time, it optimizes for unmet accuracy requirements, ensuring that each step is aligned with the goal.

[0030] Furthermore, summaries of historical evolutionary experience typically include strategies, results, and positive and negative impacts from previous rounds. For example, "PCA dimensionality reduction in round 1 was successful; the problem lay in the random forest parameters." This information is crucial for determining improvement strategies. Successful aspects should be maintained or strengthened, problematic aspects should be corrected, and unmet needs should be addressed with new optimization directions. The "iterative" nature of improvement strategies is also important. Each round is based on adjustments made in the previous round. For instance, if the random forest parameters were adjusted in round 2, round 3 might use a more efficient model to further optimize accuracy and model size. If task requirements change, such as adding a requirement for "model interpretability," historical experience can be incorporated, such as the low interpretability of the random forest in rounds 1-2. The strategy for the current round would then be adjusted to "switch to a decision tree model while maintaining PCA dimensionality reduction" to meet the new requirements.

[0031] The purpose of the solutions provided in this step is to avoid "blind optimization." By clarifying the goals through task requirements and summarizing historical experience, we can avoid repeating the same mistakes, ensuring that each round of improvement has direction and basis. For example, in the case of XX flower classification, the strategy in round 2 is not to arbitrarily adjust parameters, but to optimize in a targeted manner based on the results and goals of the previous round. This allows us to approach the goal of "accuracy ≥ 95% and model size ≤ 100MB" more quickly, improving the efficiency of evolutionary solution.

[0032] Step 2022: Generate multi-stage sub-tasks for handling the complex problem to be addressed based on a multi-stage improvement strategy, and execute each stage sub-task in sequence to obtain the current solution; Building upon step 2021, this step aims to have the aforementioned executing entity generate multi-stage sub-tasks for handling the complex problem based on a multi-stage improvement strategy, and then execute each sub-task sequentially to obtain the current solution. This multi-stage improvement strategy and its corresponding multi-stage sub-tasks both include the following sequentially arranged task processing stages: data loading, cross-validation, feature engineering, model training and prediction, ensemble learning, and workflow encapsulation and integration. In other words, the purpose of this step is to decompose the improvement strategy into standard steps of a machine learning pipeline, executing them one by one in the order of "data processing → model building → workflow encapsulation," from raw data to generating an evaluable current solution (such as a trained model and performance metrics). This structured execution method ensures the controllability and repeatability of the evolutionary process, avoiding the untraceability of results caused by fragmented operations.

[0033] Multi-stage subtasks are the concrete implementation of improvement strategies. Each subtask corresponds to a core link in the pipeline, which can be arranged in order as: loading data, cross-validation, feature engineering, model training and prediction, ensemble learning, and workflow encapsulation and integration. This phased processing logic breaks down complex machine learning tasks into sub-problems that can be optimized independently and verified sequentially. The output of each step serves as the input for the next step, ultimately forming a complete model generation process. For example, loading data is the input stage, responsible for obtaining raw data (such as the petal length and width of a flower), ensuring data integrity (no missing or duplicate values); cross-validation is the evaluation stage, dividing the data into training and validation sets (such as 5-fold cross-validation) to evaluate the model's generalization ability and provide a performance benchmark for subsequent steps; feature engineering is the optimization stage, transforming the raw features (such as PCA dimensionality reduction) to improve feature effectiveness (removing redundancy and enhancing relevance to labels); model training and prediction are the core stages, using training data to train the model (such as random forest) and generate prediction results, optimizing parameters (such as n_estimators, max_depth) to improve performance; ensemble learning is the enhancement stage, combining the prediction results of multiple base models (such as random forest and SVM) (such as voting) to improve model stability and generalization ability; workflow encapsulation and integration is the output stage, integrating the above steps into a reusable workflow (such as Docker containerization and generating API interfaces, API stands for Application Programming Interface), improving model deployment efficiency.

[0034] Taking the XX flower classification task as an example, if the improvement strategy is "to optimize features using PCA for dimensionality reduction, adjust random forest parameters to reduce model size, and improve accuracy using ensemble learning," the corresponding subtask execution process is as follows: First, load the dataset (150 samples, 4 features) and check for missing values; then, use 5-fold cross-validation to split the training set (120 samples) and the validation set (30 samples); then, perform PCA dimensionality reduction on the training set, retaining 2 principal components (explaining 95% of the variance); then train the random forest model (n_estimators=50, max_depth=5), achieving a validation set accuracy of 94% and a model size of 110MB; next, use a voting method to ensemble the random forest with SVM (Support Vector Machine), improving the validation set accuracy to 95%; finally, integrate the steps into a workflow, encapsulate it using Docker, and generate an API interface. The final solution is: ensemble model accuracy of 95% (meets task requirements), model size of 110MB (close to the 100MB constraint), and training time of 40 minutes (meets the 1-hour requirement).

[0035] This sequential execution approach offers several advantages, such as better coherence, where each step's output serves as the input for the next, ensuring a smooth workflow (e.g., the dimensionality reduction results of feature engineering directly impact model training performance); better traceability, allowing for backtracking to a specific step (e.g., feature engineering) to check for problems if model performance is poor; better optimizability, as each subtask can be adjusted independently (e.g., trying different dimensionality reduction methods in feature engineering, adjusting different parameters during model training), reducing the difficulty of solving complex problems; and higher fault tolerance, allowing for retrying or using default values ​​if a step fails (e.g., data loading errors), preventing the entire process from terminating.

[0036] Step 2023: In response to the current solution not meeting the task requirements, based on the multi-stage improvement strategy and the actual degree to which the current solution meets the task requirements, generate evolutionary experience with evolutionary orientation corresponding to the current evolutionary round; Building upon step 2022, this step aims to generate evolutionary experience with evolutionary direction based on the multi-stage improvement strategy and the actual degree to which the current solution meets the task requirements, when the aforementioned implementing entity fails to meet the task requirements. In other words, the generated evolutionary experience serves as feedback that transforms the evolutionary results into the basis for the next round of optimization. It compares the "expected goals of the improvement strategy" with the "actual performance of the current solution," revealing the effectiveness and shortcomings of the strategy, and extracting regular conclusions that guide the next round of adjustments, thus shifting the evolutionary process from blind trial and error to targeted iteration.

[0037] The core logic of this step is difference analysis, which uses task requirements (e.g., "XX flower classification requires accuracy ≥ 95%, model size ≤ 100MB") as a benchmark to measure whether the current solution (e.g., the trained model and its accuracy, model size, etc.) meets the requirements. Then, combined with multi-stage improvement strategies (e.g., "using PCA to reduce dimensionality and optimize feature engineering, adjusting random forest parameters to improve accuracy"), we analyze "which parts of the strategy achieved the expected results" and "which parts caused the problems." The current solution is a concrete representation of the evolutionary result. For example, a trained random forest model with 94% accuracy, a model size of 120MB, and a training time of 50 minutes directly reflects the effectiveness of the strategy. Task requirements are the "standards for judging whether the result is acceptable." Failure to meet any of these requirements (e.g., accuracy below 95%, model size exceeding 100MB) necessitates strategy adjustments. Evolutionary experience is the "pattern" summarized from the "difference between the result and the requirements," and it must have clear direction, telling the next round "what to retain (e.g., PCA dimensionality reduction), what to adjust (e.g., reducing the n_estimators of the random forest), and what to avoid (e.g., excessively increasing model complexity)."

[0038] Taking the task of "building a high-accuracy, small-model XX flower classification model" as an example, if the improvement strategy for the current round (round 1) is "using PCA to reduce dimensionality to 2 principal components to optimize feature engineering, and setting n_estimators=100 in random forest to improve accuracy", the task requirements are "accuracy ≥ 95%, model size ≤ 100MB". After execution, the current solution could have the following performance: accuracy 94% (not meeting the target), model size 120MB (exceeding the limit), and training time 50 minutes (meeting the requirements). At this point, it's necessary to analyze the execution effects of each strategy: In the feature engineering stage, it was expected that PCA dimensionality reduction would improve accuracy by 2%, but it actually improved from 90% to 94%, exceeding expectations. This indicates that "PCA dimensionality reduction is an effective action," as it removes redundant features (such as the high correlation between sepal length and petal length), allowing the model to focus more on key features and significantly improving feature effectiveness. In the model training stage, it was expected that setting n_estimators=100 would improve accuracy to 95%, but it only reached 94%, and the model size increased from 80MB to 120MB. This indicates that "n_estimators=100 is a negative action," meaning that too many trees lead to excessive model complexity. Although it slightly improved accuracy, it did not achieve the target and also increased the model size. In the ensemble learning stage, using a voting method to combine random forest and SVM was expected to improve accuracy by 1%, but there was no change. This indicates that "the voting method is an ineffective action," as the performance difference between the two base models is not significant (random forest 94%, SVM 93%), and the advantages cannot be integrated through voting.

[0039] From these differences, we can extract evolutionary lessons with an evolutionary orientation: "PCA dimensionality reduction effectively improves accuracy, and should continue to be used in the next round" (preserve effective actions and avoid losing existing advantages due to strategy adjustments); "Random Forest with n_estimators=100 caused the model size to exceed the limit and fail to reach the accuracy target, so n_estimators should be reduced to 50 in the next round to balance model size and accuracy" (correct ineffective actions and adjust parameters to address the root cause of the problem); "The voting method of integrating Random Forest and SVM did not improve accuracy, so more effective integration methods (such as stacking) or changing the base model (such as XGBoost, eXtreme Gradient Boosting, an optimized distributed gradient boosting decision tree algorithm library) can be tried in the next round" (avoid ineffective actions and find more suitable integration methods). These lessons are not general "summaries" but rather "action guidelines" specific to each step and each parameter, which can directly guide the adjustment of the strategy in the next round.

[0040] The value of evolutionary experience lies in its clear direction; that is, it should be able to answer the question of "what to do and what not to do" in the next round. For example, if the task requirements include multiple objectives (such as simultaneously requiring accuracy, training time, and model size), the experience needs to take into account the differences in each dimension: if the current solution meets the accuracy target but the training time exceeds the target (e.g., 1.5 hours), the experience needs to explain that "the batch_size=32 of the model training caused the training time to be too long, and the batch_size should be increased to 64 in the next round to shorten the time"; if the task requirements change (such as adding the requirement of "model interpretability"), the experience needs to adapt in a timely manner: if the random forest model of the current solution has low interpretability (the importance of features is unclear), the experience needs to suggest "changing to a model with high interpretability (such as a decision tree) or adding SHAP value analysis in the next round to improve the interpretability of the model."

[0041] In other words, the evolutionary experience generated in response to the current solution's failure to meet task requirements, as described in this step, is a crucial turning point in the evolutionary process from failure to progress. It transforms the results of unmet requirements into valuable learning material, analyzing differences and extracting patterns to make the next round's strategy more accurate and efficient. For example, in the case of flower classification, the next round's strategy might retain PCA dimensionality reduction, reduce the number of n_estimators in the random forest, and try stacked ensemble methods. These adjustments directly target the "root cause" of the current solution's problems (accuracy not meeting the target, model size exceeding the limit), significantly increasing the probability of meeting the task requirements in the next round. This "feedback-adjustment" cycle is the core driving force behind the evolutionary agent's "continuous optimization," with each "unmet requirement" becoming a stepping stone to "get closer to the goal."

[0042] Step 2024: Update the historical evolutionary experience summary using the evolutionary experience of the current evolutionary cycle; Building upon step 2023, this step aims to have the aforementioned implementing entity update the historical evolutionary experience summary using the evolutionary experience of the current evolutionary cycle. This involves transforming the learning outcomes of a single evolutionary cycle into long-term reusable knowledge. Through integration, comparison, and correction, it allows the historical experience summary to become the "knowledge foundation" for subsequent cycles, ensuring that the evolutionary process always iterates based on past experience, avoiding repeated trial and error, and simultaneously strengthening the reuse of successful strategies.

[0043] The evolutionary experience of the current evolutionary round consists of specific conclusions drawn from difference analysis (e.g., "Round 1: PCA dimensionality reduction + random forest (n_estimators=100), accuracy 94%, model size 120MB; experience: PCA dimensionality reduction effectively improves accuracy, but n_estimators need to be adjusted to control model size"), focusing on "the actions, effects, and patterns of this round." The historical evolutionary experience summary, on the other hand, is a collection and integration of experiences from all previous rounds (e.g., "Round 0: Original feature training, accuracy 90%, model size 80MB; experience: Original features are redundant, feature engineering needs optimization"; "Round 1: PCA dimensionality reduction + random forest (n_estimators=100), accuracy 94%, model size 120MB; experience: PCA dimensionality reduction is effective, but n_estimators need to balance accuracy and model size"). It represents the accumulation of evolutionary knowledge, focusing on which strategies are effective in the long term, which problems recur, and what general patterns exist. Its technical principle can be broken down into three stages: "addition, integration, and correction." Addition involves incorporating current experience into the historical database, forming a "progressive" experience chain (e.g., stage 0 → stage 1 → stage 2). Integration combines current experience with historical experience to concretize or improve previous conclusions (e.g., historical experience mentions "feature engineering needs optimization," while current experience adds "PCA dimensionality reduction is an effective method for feature engineering," making the conclusion more operational). Correction uses current experience to correct erroneous assumptions in historical experience (e.g., historical experience may implicitly suggest "the larger n_estimators are, the higher the accuracy," while current experience corrects this by stating "n_estimators=100 leads to an oversized model," to "n_estimators needs to balance accuracy and model size," avoiding repeating the same mistakes in subsequent stages).

[0044] Taking the "XX Flower Classification Task" as an example, the evolutionary experience of the current round (round 1) is: "Using PCA to reduce dimensionality to 2 principal components to optimize feature engineering, a random forest model (n_estimators=100) was trained, achieving an accuracy of 94% and a model size of 120MB; Experience: PCA dimensionality reduction effectively improved accuracy (from 90% to 94%), but n_estimators=100 caused the model size to exceed the 100MB limit, requiring adjustment of this parameter to balance the two." The historical evolutionary experience summary before the update includes the conclusion of round 0: "Training a random forest with the original features (n_estimators=50) achieved an accuracy of 90% and a model size of 80MB; Experience: Redundancy exists in the original features (such as a high correlation between sepal length and petal length), requiring optimization of feature engineering to improve accuracy." During the update process, the experience from round 1 is first added to the history database, forming an experience chain of "round 0 → round 1". Then, the conclusions are integrated, combining "the need to optimize feature engineering" with "PCA dimensionality reduction is an effective method for feature engineering", resulting in a more specific rule: "Optimizing feature engineering is the key to improving accuracy, and PCA dimensionality reduction can effectively remove redundant features and enhance the correlation between features and labels". Finally, the assumption is corrected. If round 0 implicitly assumes that "the larger the n_estimators, the higher the accuracy", the experience from round 1 will correct this assumption, adding that "although increasing n_estimators can slightly improve accuracy, it will significantly increase the model size, and the two need to be balanced according to the task requirements".

[0045] Furthermore, the updated historical evolutionary experience summary has several values: First, it improves reusability. Subsequent rounds (such as round 2) can directly refer to the conclusions that "PCA dimensionality reduction is effective" and "n_estimators need to be balanced" to formulate a strategy of "PCA dimensionality reduction + random forest (n_estimators=50)" to avoid repeated trial and error. Second, it enables dynamic optimization. As the rounds increase, historical experience will be continuously improved (e.g., the result of round 2 is "accuracy 95%, model size 90MB", and the experience will supplement "n_estimators=50 is the current optimal parameter"), allowing subsequent rounds (such as round 3) to directly reuse this parameter. Third, it improves retrieval efficiency. Historical experience is usually classified by strategy type (such as "feature engineering experience", "model parameter experience", "ensemble learning experience"). For example, under "feature engineering experience", conclusions such as "PCA dimensionality reduction is effective" and "normalization helps SVM accuracy" are stored, and under "model parameter experience", conclusions such as "random forest n_estimators=50 is the optimal parameter for XX flower classification" are stored, making it convenient for subsequent rounds to quickly retrieve the required experience.

[0046] The solution provided in this step aims to give the evolutionary process "memory," with the experience of each round becoming the knowledge support for subsequent rounds. From "90% accuracy in round 0" to "94% in round 1," and then to "95% in round 2," each step relies on the accumulation and reuse of historical experience. This cycle of "experience accumulation-reuse-optimization" is the key driving force for the evolutionary agent to continuously approach and even exceed the task requirements. It makes evolution no longer "random trial and error," but "directional and evidence-based iteration."

[0047] Step 203: Take the next evolutionary round as the new current evolutionary round, and repeat the evolutionary solution steps until the target solution that meets the task requirements is obtained.

[0048] This step is based on the premise that the evolutionary solution steps described in step 202 have been executed once in each evolutionary round. The aim is for the aforementioned agent to treat the next evolutionary round as the new current evolutionary round and repeatedly execute the evolutionary solution steps until the target solution that meets the task requirements is obtained. The objective is to use iterative iteration and experience-driven approaches to allow the evolutionary agent to adjust its strategy in each round based on previous experience, gradually narrowing the gap between the current solution and the target solution, ultimately achieving a balance between multi-dimensional task requirements.

[0049] The core logic of this step can be simplified as "step-by-step closed-loop optimization": each evolutionary round (e.g., round 1, round 2) is a "current node," corresponding to a complete "strategy formulation-execution-evaluation" process. This involves determining multi-stage improvement strategies, generating and executing multi-stage sub-tasks, obtaining the current solution, evaluating whether it meets the requirements, and updating historical experience. When the current solution does not meet the requirements, the aforementioned execution entity sets the "next evolutionary round" (e.g., round 2) as the "new current round," repeating the above process. However, the strategy will be adjusted based on the experience of the previous round (e.g., retaining effective strategies and correcting parameters that cause problems) to avoid repeated trial and error.

[0050] Taking the flower classification task as an example, the task requirements are "accuracy ≥ 95%, model size ≤ 100MB, training time ≤ 1 hour". The result of round 1 is: using PCA dimensionality reduction (2 principal components) + random forest (n_estimators=100) for training, achieving an accuracy of 94% (not meeting the target), a model size of 120MB (exceeding the target), and a training time of 50 minutes (meeting the requirements). At this point, the execution entity determines that the current solution does not meet the requirements and proceeds to round 2, making it the new current round. The strategy for round 2 is an adjustment based on the experience of round 1: retaining PCA dimensionality reduction (because it effectively improves accuracy) and adjusting the random forest parameters (reducing n_estimators from 100 to 50 to address the problem of an overly large model). After execution, the current solution is an accuracy of 95% (meeting the target), a model size of 90MB (meeting the target), and a training time of 45 minutes (meeting the requirements). At this point, the aforementioned execution entity evaluates that the current solution satisfies all task requirements, and then terminates the loop, outputting the current solution of round 2 as the target solution (for example, packaged into a deployable Docker image for use in real-world flower classification scenarios).

[0051] To ensure the effectiveness of the loop process, the following constraints can be set: 1) Dual protection of termination conditions: It will not loop indefinitely, but sets two termination conditions: "meeting the requirements" and "maximum number of rounds limit". The former is ideal termination, which stops immediately as long as the current solution meets all task requirements; the latter is fallback termination, which returns the "current optimal solution" (e.g., 94.8% accuracy and 98MB model size in round 10) if the requirements are not met after the loop reaches the preset maximum number of rounds (e.g., 10 rounds) to avoid wasting resources; 2) Adaptive strategy adjustment: The strategy adjustment range of each round will change dynamically according to the results of the previous round. For example, if the model size in round 1 exceeds the limit by 20MB (120MB → 100MB), round 2 will reduce n_estimators from 100 to 50 (a significant reduction); if the model size in round 2 is 95MB (still exceeding the limit by 5MB), round 3 might reduce n_estimators from 50 to 40 (a smaller reduction), gradually approaching the target and avoiding "over-adjustment" or "under-adjustment"; 3) Continuous reuse of experience: The strategy in each round is based on previous experience, avoiding "starting from scratch". For example, the experience of "PCA dimensionality reduction is effective" in round 1 will be reused in rounds 2 and 3, only requiring adjustment of model parameters (such as n_estimators, max_depth), saving time of "re-exploring feature engineering methods" (for example, not trying inefficient strategies such as "original feature training" again).

[0052] The core value of the iterative process described in this step lies in giving evolution a memory and providing a basis for adjustments. It addresses the multi-dimensional needs of complex problems (such as accuracy, model size, and training time) through a "loop-feedback-adjustment" mechanism. For example, round 1 solves the problem of improving accuracy, but introduces a new problem of an oversized model; round 2, by adjusting parameters, maintains the improvement in accuracy while solving the problem of an oversized model, ultimately achieving the goal.

[0053] The complex problem-solving method based on evolutionary agents provided in this disclosure achieves automated and evolutionary solving of complex problems through a closed-loop process of "task requirements - historical evolutionary experience summary - multi-stage improvement strategy - multi-stage sub-task generation and execution - evolutionary experience generation and update - iterative solution". First, based on the current task requirements and the evolutionary experience summary of different historical solutions, a multi-stage improvement strategy compared to the previous round is automatically determined, replacing traditional manual intervention and avoiding the lag of subjective judgment. Then, the complex problem is broken down into progressively executable multi-stage sub-tasks and executed sequentially to obtain the current solution, improving the structure and controllability of the solution process. If the current solution does not meet the task requirements, experience containing evolutionary direction is generated based on the multi-stage improvement strategy and the actual satisfaction level of the current solution, and the historical evolutionary experience summary is updated, realizing the systematic accumulation and reuse of past successful experiences and avoiding starting from scratch in each round of improvement. Finally, by iteratively executing the above steps, continuous iteration and optimization are performed until the target solution that meets the task requirements is obtained, achieving dynamic improvement of model performance and effectively addressing the multi-dimensional requirements of complex tasks. This solution can automatically adapt to changes in task requirements without human intervention. Through the accumulation of historical experience and dynamic optimization, it significantly improves the efficiency, accuracy, and evolutionary iteration efficiency of solving complex problems.

[0054] To further understand step 2022, please refer to [the relevant documentation / reference]. Figure 3 , Figure 3 A flowchart of a method for determining the current solution based on a multi-stage improvement strategy is provided for embodiments of this disclosure, wherein process 300 includes the following steps: Step 301: Based on the multi-stage improvement strategy, select the current parent solution from the memory evolution library that stores all historical solutions; The memory evolution library is a database that stores the current solutions of all past evolutionary rounds, such as the "PCA dimensionality reduction + random forest (n=50)" model in round 1 and the "PCA dimensionality reduction + random forest (n=40)" model in round 2, along with their performance metrics (accuracy, model size, training time, etc.). These historical solutions are a culmination of experience from the evolutionary process, recording which strategies are effective and which parameter combinations can balance multi-dimensional requirements.

[0055] The current parent solution is the base model for this round of improvement selected by the aforementioned execution entity from the memory evolution library. The selection logic revolves around a high degree of correlation with the current multi-stage improvement strategy; that is, the parent solution must contain successful experiences targeted by the current improvement strategy. For example, if the current improvement strategy is "maintaining PCA dimensionality reduction (feature engineering optimization) and adjusting the max_depth parameter of random forest to improve accuracy," the aforementioned execution entity will select "historical solutions that perform well in PCA dimensionality reduction and have accuracy close to the target" (such as "PCA dimensionality reduction + random forest (n=50)" in round 1, with an accuracy of 95% and a model size of 90MB) as the parent solution. This inherits successful experiences and avoids starting from scratch in this round of improvement.

[0056] Step 302: Based on the current parent solution, task requirements, and multi-stage improvement strategy, generate multi-stage sub-tasks to handle the complex problem to be addressed; Multi-stage subtasks are an improved version of the parent solution's process. Their generation logic is "using the parent solution as a baseline, retaining valid steps, and adjusting steps that need optimization." Specifically, they can be broken down into the following parts: 1) Retain valid parts of the parent solution: The parts of the parent solution that are consistent with the current improvement strategy (such as the "PCA dimensionality reduction" feature engineering of the parent solution, which conforms to the strategy of "keeping feature engineering optimization") will be retained as "fixed steps" of the subtask (such as "feature engineering stage: perform PCA dimensionality reduction to 2 principal components"). 2) Adjusting the optimization steps of the parent solution: Parts of the parent solution that do not meet the goal or are inconsistent with the current strategy (such as the parent solution's "random forest max_depth=default", which does not meet the strategy of "adjusting model parameters to improve accuracy") will be adjusted as "variable steps" of the subtask (such as "model training phase: set random forest max_depth=5"). 3) Fit the task requirements: All subtasks are designed around "meeting the task requirements" (e.g., "model size ≤ 100MB"), avoiding adjustments that may cause new problems (e.g., not setting max_depth too large to prevent the model from becoming overly complex).

[0057] Taking the XX flower classification task as an example, if the parent solution is "PCA dimensionality reduction + random forest (n=50)" in round 1 (accuracy 95%), the current improvement strategy is "adjusting max_depth to improve accuracy". The generated subtasks may include: loading the XX flower dataset → 5-fold cross-validation → PCA dimensionality reduction to 2 principal components → training the random forest (max_depth=5) → integrating SVM using voting → packaging into a Docker workflow. These subtasks focus on the current improvement direction (adjusting max_depth) while retaining the effective steps of the parent solution (PCA dimensionality reduction).

[0058] Step 303: Execute the subtasks of each stage in sequence, and determine the task execution result of the last stage's subtask as the current solution.

[0059] Multi-stage subtasks need to be executed sequentially, with the output of each subtask serving as the input for the next (e.g., the output of loading data is a "clean original dataset," which serves as the input for cross-validation; the output of cross-validation is "training set + validation set," which serves as the input for feature engineering). This "pipeline-like" execution ensures the repeatability and controllability of the results; the same input and process will inevitably produce the same output, facilitating the evaluation of the effectiveness of this round of improvements.

[0060] The current solution is the output of the last subtask (workflow encapsulation), containing three parts: a trained model (e.g., "PCA dimensionality reduction + random forest (n=50, max_depth=5)"), performance metrics (e.g., accuracy 96%, model size 92MB, training time 40 minutes), and a deployable workflow (e.g., a Docker image containing the model and all dependent environments). For example, in the XX flower classification task, after executing the subtask, the current solution inherits the PCA dimensionality reduction (effective step) from the parent solution, adjusts the max_depth (step requiring optimization), and improves the accuracy from 95% to 96%, while maintaining the model size at 92MB (meeting the requirement of ≤100MB).

[0061] Steps 301-303 provided in this embodiment constitute the core scheme of iterative improvement based on historical experience. Specifically, it selects a "parent solution" (i.e., a historical model that performed well in the past) from the memory evolution library storing past models, generates targeted sub-tasks based on the current improvement strategy and task requirements, and then executes them sequentially to obtain the result of this round of improvement (the current solution). The technical principle is that evolution is not about trial and error from scratch, but rather about targeted adjustments based on past successful experiences, ensuring that each round of improvement has a clear baseline and goal.

[0062] exist Figure 3 Based on the illustrated embodiment, considering that in some cases the task requirements may include some personalized requirements that cannot be covered by the above-described general stage sub-tasks, please refer to... Figure 4 , Figure 4 A flowchart of a method for processing personalized needs provided in this disclosure embodiment is included in process 400, which includes the following steps: Step 401: In response to the personalized requirements included in the task requirements of the complex problem to be processed, generate temporary stage subtasks for the personalized requirements; Personalized requirements are special requirements within the task specifications that cannot be covered by general stage subtasks (such as "the model must support incremental training," "the output must include an interpretable report," and "the model size must be suitable for edge devices (e.g., ≤50MB)" in machine learning problems). These requirements are usually strongly related to the business scenario (e.g., recommendation systems need to "consider real-time user click behavior," and medical diagnostic models need to "output feature importance explanations"), and cannot be met by the fixed steps of a general process. Temporary stage subtasks are supplementary steps customized by the aforementioned executing entity for personalized requirements, and their core is to transform personalized requirements into specific executable operations.

[0063] For example, if the personalized requirement is "the model must support incremental training" (business data is updated in real time, requiring frequent model updates), the temporary subtask might be "load new data → merge the original training set → retrain the model using an incremental learning algorithm (such as an online random forest) (retaining the original parameters)". If the personalized requirement is "the output results must include an interpretability report" (business personnel need to understand the reasons for the model's predictions), the temporary subtask might be "calculate the SHAP value (feature importance) using the trained model → generate a visualization report (such as a feature contribution heatmap)". If the personalized requirement is "the model size must be suitable for edge devices (≤50MB)" (it needs to be deployed on mobile phones or IoT devices), the temporary subtask might be "use model compression techniques (such as pruning, quantization) → optimize the model structure (such as reducing the number of convolutional layers) → verify the size of the compressed model".

[0064] Furthermore, the "temporary" nature of temporary subtasks can also be reflected in the fact that they are only generated when personalized needs exist, and are automatically removed when the needs disappear, without affecting the regular execution of the general process.

[0065] Step 402: Determine the temporary insertion position of the temporary stage subtask among the existing multiple stage subtasks; The determination of the insertion position generally needs to follow the principle of "logical dependency + process coherence," that is, temporary subtasks should be inserted into positions that "do not disrupt the general process logic" and "satisfy personalized dependency relationships." Specifically: 1) Dependencies: The execution of temporary subtasks depends on the output of certain steps in the general workflow. For example, the temporary subtask of "calculating SHAP values" depends on the output of the "model training" step (the trained model), so it needs to be inserted after "model training"; the temporary subtask of "incremental training" depends on the output of the "loading data" step (the original training set) and the input of "new data", so it needs to be inserted after "loading data" and before "feature engineering" (feature processing is performed after merging the data). 2) Process Continuity: The insertion of temporary subtasks must not disrupt the "pipeline" execution logic of the general process (such as "loading data → cross-validation → feature engineering → model training → ensemble learning → workflow encapsulation"). For example, the temporary subtask of "model compression" should be inserted after "model training" and before "workflow encapsulation" (compressing the trained model and then encapsulating it into a deployable workflow) without interrupting the continuous process of "training → encapsulation".

[0066] Taking the personalized requirement that "the recommendation system needs to consider the user's real-time click behavior" as an example, the general process is "load historical user behavior data → feature engineering (extract user preference features) → model training (train the recommendation model with historical data) → generate recommendation list". The temporary subtask can be "get the user's click data in the last hour in real time → merge historical data → adjust feature input (add real-time click features)". In this case, the insertion position should be after "load data" and before "feature engineering" because "merging data" depends on the output of "loading historical data", and "feature engineering" needs to process the merged complete data (historical + real-time). This way, the insertion will not break the process logic of "loading → feature processing → training".

[0067] Step 403: Insert the temporary stage subtask into the execution sequence of the existing multiple stage subtasks according to the temporary insertion position, so that the stage subtasks are executed sequentially according to the order of the execution sequence.

[0068] The insertion operation involves the aforementioned executor "embedding" a temporary subtask into the execution sequence of the general process at a predetermined position, forming a combined process of "general steps + temporary steps". For example, if the general process is "load data → cross-validation → feature engineering → model training → ensemble learning → workflow encapsulation", and the personalized requirement is "output interpretability report", and the temporary subtask is "calculate SHAP value → generate feature importance report", and the insertion position is after "model training" and before "ensemble learning", then the execution sequence after insertion becomes: "load data → cross-validation → feature engineering → model training → calculate SHAP value → generate feature importance report → ensemble learning → workflow encapsulation".

[0069] The execution logic proceeds sequentially according to the inserted order, with the output of each step serving as the input for the next. For example, the "Model Training" step outputs a "trained random forest model," the "Calculate SHAP Values" step receives the model, calculates the contribution of each feature to the prediction result, and outputs a "SHAP Value Matrix." The "Generate Feature Importance Report" step receives the "SHAP Value Matrix," generates a visualization report (such as "Petal length is the most important feature for predicting XX flower species"), and uses the report as input for the "Ensemble Learning" step (if ensemble learning requires adjusting model weights based on interpretability results).

[0070] It should be noted that the execution of temporary subtasks usually does not affect the core results of the general process (such as model accuracy and model size), but it will supplement the results for personalized needs (such as interpretability reports and incrementally trained models). For example, after the execution of the temporary subtask of "model compression", the model size is reduced from 80MB to 45MB (meeting the needs of edge devices), but the model accuracy remains at 95% (the core results of the general process remain unchanged).

[0071] This embodiment adds a personalized extension interface to the general evolutionary process through steps 401-403. Specifically, by generating, inserting, and executing temporary subtasks, it satisfies the specific requirements of the task without disrupting the core logic of the general process. This design allows the evolutionary agent to both "cope with the multi-dimensional needs of general scenarios" (such as accuracy and model size) and "adapt to the personalized needs of special scenarios" (such as real-time performance and interpretability), thus improving the versatility and applicability of the solution.

[0072] Based on any of the above embodiments, after each stage subtask is executed, a subtask verification set corresponding to the executed stage subtask can be determined. This subtask verification set is generated based on the stage improvement strategy corresponding to the corresponding stage subtask. Then, the task execution status of the corresponding stage subtask is verified using this subtask verification set, and the next stage subtask is executed only after the verification is successful. Furthermore, if any stage subtask fails verification, the corresponding stage subtask can be regenerated based on the feedback of the failed verification until it passes verification or after retries exceed a preset number, an error message is returned and other unexecuted stage subtasks are terminated.

[0073] The sub-task validation set is a set of validation criteria and data designed by the aforementioned execution entities for the objectives of each stage's sub-tasks. It does not directly evaluate the global task requirements (e.g., "accuracy ≥ 95%)," but rather focuses on the supporting role of the sub-task at that stage in achieving the global objective. For example, if the improvement strategy for a certain stage is "using PCA to reduce dimensionality and improve feature effectiveness" (the goal is to retain key information and reduce redundancy), the validation set will include two parts: data metrics (e.g., the variance ratio explained by the reduced-dimensional features must be ≥ 90% to ensure that not too much information is lost) and performance metrics (e.g., when training a logistic regression model with the reduced-dimensional features, the validation set accuracy must be ≥ 2% higher than the model trained with the original features, proving that dimensionality reduction does indeed improve feature effectiveness). As another example, if the stage improvement strategy is "adjusting the max_depth of the random forest to avoid overfitting," the validation set will be a generalization metric (e.g., the difference between the validation set accuracy and the training set accuracy ≤ 5%, ensuring that the model has not overlearned the training data). The "locality" of these validation sets allows for more precise checks and can quickly pinpoint problems in the stage's sub-tasks, such as excessive dimensionality reduction leading to information loss, or improper parameter settings causing overfitting.

[0074] The reason for immediate verification after each stage's subtask is to prevent errors from propagating. The subtasks in the evolutionary process are interdependent (e.g., "data loading → cross-validation → feature engineering → model training"). Errors in previous stages can affect all subsequent steps like dominoes. For example, failing to handle missing values ​​during data loading can lead to biased dimensionality reduction results in feature engineering, resulting in lower model training accuracy. Verification after each stage stops the error propagation process early, saving subsequent resources. For example: Data loading phase: The subtask is "retrieving the XX flower dataset from the database", and the validation set is "data integrity check" (e.g., missing value ratio ≤ 1%, duplicate value ratio ≤ 0.5%). If the missing value ratio reaches 5%, the data cleaning subtask (e.g., filling missing values ​​with the mean) will be triggered, and loading and validation will be re-executed until the requirements are met. Cross-validation phase: The subtask is to "divide the data into a 5-fold training set and a validation set". The validation set is used for "distribution consistency check" (e.g., the difference between the label distribution of the validation set and the training set is ≤5%). If the proportion of a certain type of flower in the validation set is 10% higher than that in the training set, the partitioning method will be adjusted (e.g., stratified sampling), and the cross-validation subtask will be regenerated until the distribution is consistent. Feature engineering (PCA dimensionality reduction) phase: The subtask is "reducing the dimensionality of the 4 original features to 2 principal components", and the validation set is "explained variance ratio ≥ 90%". If the explained variance ratio is only 80%, the number of principal components will be increased (e.g., from 2 to 3), and dimensionality reduction and validation will be performed again until the requirements are met.

[0075] When a subtask fails validation at a certain stage, the aforementioned execution entity can enter a loop of regeneration-re-execution-revalidation until validation passes or the maximum number of retries (e.g., 3 times) is reached. This design ensures flexibility (allowing parameter adjustments to resolve issues) while avoiding infinite loops (wasting resources). For example, during the model training phase: The phased improvement strategy is to "adjust the n_estimators of the random forest to improve accuracy" (the goal is to achieve a validation set accuracy of ≥92%). First run: n_estimators=50, validation set accuracy 90% (failed); Retry 1 time: Adjust n_estimators=100, validation set accuracy 91% (still failed); Retry 2 times: Adjust n_estimators=150, validation set accuracy 93% (pass); If the retry fails after 3 attempts (e.g., the highest accuracy is only 91%), the above-mentioned execution entity can terminate subsequent subtasks (such as ensemble learning, workflow encapsulation) and return the message "The model training phase could not achieve the expected results". It is recommended to adjust the phase strategy (e.g., switch to the XGBoost model).

[0076] This embodiment provides a design for verification after the execution of each stage subtask. The core is to ensure that each improvement meets the stage goal through the "local verification + error blocking" mechanism, and avoid small errors accumulating into big problems. In essence, it breaks down the complex global optimization into verifiable small stage goals. Through the small successes of each stage, the full satisfaction of the global task requirements is finally achieved.

[0077] To deepen your understanding of how evolutionary memory is stored, please also refer to [link to relevant documentation]. Figure 5 , Figure 5 A flowchart of a hierarchical memory storage method provided in this disclosure embodiment is included in process 500, which includes the following steps: Step 501: Store the content generated during the evolutionary solution process as transient memory; Immediate memory serves as a cache for temporarily storing all intermediate content during the evolutionary process. Examples include data loading logs ("2025-12-30 23:00: Retrieved 150 XX flower samples from the database, no missing values"), intermediate results of feature engineering ("Used PCA to reduce 4 features to 2 principal components, explaining 90% of the variance"), parameter tuning records during model training ("Increased random forest n_estimators from 50 to 100, max_depth set to 5"), and validation set performance metrics ("Accuracy 92%, model size 95MB"). This content constitutes the "raw data" of the execution process, containing a wealth of details, but its large volume (potentially hundreds of MB per round) prevents long-term storage. Its purpose is to provide "raw materials" for the generation of subsequent intermediate memories, much like how humans use "short-term memory" to remember recent events, such as "ate bread this morning," but forget specific details (like the brand of the bread) after a while.

[0078] Step 502: In response to the cumulative storage of transient memory exceeding the preset upper limit of the amount of preceding information, aggregate all currently accumulated transient memories and historical intermediate memories, and generate a semantic summary for the aggregation result as a new intermediate memory; When the accumulated amount of transient memory exceeds a preset limit (e.g., 1GB, adjusted according to the resources of the aforementioned execution entity), aggregation processing will be automatically triggered: semantic fusion of the current transient memory and historical intermediate memory will be performed to extract key information and generate a concise summary. The aggregation logic is "redundancy removal and core retention." For example, if there are 10 log entries in the transient memory mentioning "no missing data loaded," only one will be retained; irrelevant details such as specific timestamps and log formats will be ignored, and only content related to the evolutionary goal (such as feature engineering methods, model parameters, and performance changes) will be retained.

[0079] For example, in round 3 of the XX flower classification task, the immediate memory contains details such as "loading 150 samples, PCA dimensionality reduction to 2 principal components, random forest n=100, accuracy 92%". The aggregated intermediate memory might be: "Round 3: Feature engineering using PCA dimensionality reduction (2 principal components, explaining 90% of variance), model training using random forest (n=100, max_depth=5), validation set accuracy 92%, model size 95MB". This summary removes useless details and retains information valuable for subsequent evolution, such as "PCA dimensionality reduction" being an effective feature engineering method, "n=100" being the model parameters for the current round, and "accuracy 92%" reflecting the effectiveness of the strategy. Intermediate memory is like human "intermediate memory," for example, "ate bread in the morning" is simplified to "ate staple food for breakfast," retaining core information but forgetting details.

[0080] Step 503: Transfer intermediate memories that have been retained more than a preset number of times and / or whose importance exceeds a preset level to long-term memories.

[0081] Long-term memory consists of frequently used or evolutionarily significant content in intermediate memory, serving as the "core knowledge base" of an evolutionary agent. There are two conditions for its retention: first, the number of times it is retained exceeds a preset number (e.g., if an intermediate memory is referenced in three subsequent rounds of evolution, it indicates it is "useful experience"); second, its importance exceeds a preset level (e.g., if a strategy improves accuracy by 5% or reduces model size by 20%, it indicates it is a "key strategy").

[0082] For example, the intermediate memory of round 3, "PCA dimensionality reduction + random forest (n=100), accuracy 92%", if referenced in rounds 4, 5, and 6 (to adjust their respective feature engineering and model parameters), or if it improves the accuracy from 90% to 92% (reaching the critical point required by the task), will be transferred to long-term memory. Long-term memory is like human "long-term memory," such as the skill "learning to ride a bicycle," which is remembered forever and will not be forgotten. It will not be automatically deleted unless it is manually marked as "obsolete" (for example, when a new strategy is more effective, "PCA dimensionality reduction + random forest" may be replaced by "automatic feature engineering + XGBoost").

[0083] This embodiment provides a hierarchical memory management mechanism through steps 501-503. The essence of this mechanism is the process of extracting information from details to summaries, from temporary to permanent information. Immediate memory retains execution details, intermediate memory simplifies to key information, and long-term memory retains core experiences. This design allows the evolutionary agent to both "remember" the details of the execution process (for debugging and optimization) and "forget" useless information (saving resources), while simultaneously "retaining" useful experiences (improving evolutionary efficiency). It's like a person organizing drawers: grouping scattered items (immediate memory) into folders (intermediate memory), and placing frequently used folders (long-term memory) in prominent locations, making finding things more efficient.

[0084] Based on any of the above embodiments, to deepen the understanding of this evolutionary memory bank, the memory evolution bank and the evolutionary memory system in which it resides are also specifically described here: This evolutionary memory bank uses a tree diagram to record all historical solutions. It serves as the memory storage unit in an evolutionary memory system based on a multi-population island parallel model and a multi-dimensional phenotypic elite archiving algorithm. The multi-population island parallel model has a ring topology, formed by concatenating ring strips corresponding to the number of islands. Each ring strip stores the historical solutions belonging to the corresponding population on the respective island. The elite solutions for each population are recorded using a multi-dimensional table provided by the multi-dimensional phenotypic elite archiving algorithm. In other words, this evolutionary memory system, through a combination of structured storage, parallel evolution, and multi-dimensional optimization, achieves effective management, efficient utilization, and precise selection of historical solutions. Essentially, it simulates the population diversity and survival-of-the-fittest principle in natural evolution, allowing the agent to quickly converge to a solution that meets the task requirements while preserving the exploration space.

[0085] The evolutionary memory bank, serving as the system's storage unit, employs a tree-graph structure to record the "origin and evolutionary relationship" of all historical solutions. Each historical solution (e.g., "Round 3: PCA dimensionality reduction + Random Forest (n=100)") is a "node" in the tree, with its parent node being the "parent solution that generated this solution" (e.g., "Round 2: PCA dimensionality reduction + Random Forest (n=50)"), and its child nodes being "child solutions that evolved from this solution" (e.g., "Round 4: PCA dimensionality reduction + Random Forest (n=150)"). This structure resembles an evolutionary family tree, clearly tracing the evolutionary path (e.g., the tree-graph allows quick viewing that "n=150 in Round 4 is adjusted from n=100 in Round 3"), while also preserving evolutionary diversity (e.g., the child node of Round 3 might have two directions: one adjusting n=150, and the other adjusting max_depth=6, recording different exploration directions). For example, in the memory bank of the XX flower classification task, the tree diagram may have a main branch: "Round 1 (original features + logistic regression, accuracy 85%) → Round 2 (PCA dimensionality reduction + random forest, n=50, accuracy 90%) → Round 3 (PCA dimensionality reduction + random forest, n=100, accuracy 92%) → Round 4 (PCA dimensionality reduction + random forest, n=150, accuracy 93%)", while there is a branch record "Round 3 → Round 4 (PCA dimensionality reduction + XGBoost, accuracy 91%)", which retains another evolutionary direction "from random forest to XGBoost".

[0086] The core architecture of this evolutionary memory system is a multi-population island parallel model, which divides the evolutionary process into multiple populations (islands). Each population independently executes evolutionary steps (such as using different feature engineering methods and model algorithms), while exchanging elite solutions through a circular topology. The design logic of the circular topology is that each island only exchanges information with its left and right adjacent islands (e.g., island 1 → island 2 → island 3 → island 1). This avoids information overload caused by "fully connected" systems (where each island receives a large number of solutions that it cannot process) while maintaining information flow between populations (for example, if the elite solution "PCA dimensionality reduction + random forest, accuracy 92%" from island 1 is passed to island 2, island 2 can use this solution as its parent solution and combine it with its own normalization method to generate a new solution "normalization + PCA dimensionality reduction + SVM"). For example, the XX flower classification system has 3 islands: island 1 uses "PCA dimensionality reduction + random forest", island 2 uses "normalization + SVM", and island 3 uses "original features + XGBoost". Each island evolves independently, exchanging elite solutions every 5 rounds, so that each island can obtain good solutions from other populations and expand its own evolutionary direction.

[0087] The key to selecting elite solutions is the multi-dimensional phenotypic elite archive algorithm, where "phenotypic" refers to the multi-dimensional features of the solution (such as accuracy, model size, and training time). The core steps of the algorithm are: recording the features of each solution using a multi-dimensional table (e.g., "Solution 1: 92% accuracy, 95MB model size, 45 minutes training time; Solution 2: 95% accuracy, 98MB model size, 55 minutes training time; Solution 3: 94% accuracy, 105MB model size, 50 minutes training time"). Then, based on the task requirements (e.g., "accuracy ≥ 95%, model size ≤ 100MB, training time ≤ 1 hour"), selecting solutions that satisfy all objectives (e.g., Solution 2 meets all indicators and is selected as an elite solution). Finally, the elite solutions are stored in the archive and exchanged via a circular topology. This method avoids bias (e.g., Solution 3 has high accuracy but exceeds the model size limit, and is not a true elite solution), ensuring that the evolutionary direction is consistent with the task requirements. For example, in the XX flower classification task, solution 2 is the only solution that satisfies "accuracy of 95%, model size of 98MB, and training time of 55 minutes". It will be selected as the elite solution of this population and passed on to neighboring islands to become the parent solution of other populations.

[0088] The evolutionary memory system and evolutionary memory bank design provided in this embodiment are similar to the parallel evolution of multiple species in nature, maintaining diversity through gene exchange, and ultimately the species that adapt to the environment survive. The evolutionary memory system allows intelligent agents to also "survive to the fittest," that is, quickly find the optimal solution that meets the task requirements. For example, if there is only one population (using PCA dimensionality reduction + random forest), it may get stuck in a local optimum of "adjusting the n parameter" (e.g., when n=150, the accuracy is 93%, but the model size is 105MB, which exceeds the limit); while in a multi-population system, the elite solution of Island 2, "normalization + SVM, accuracy 95%, model size 90MB", can be passed to Island 1. Island 1 uses this solution as the parent solution to generate a new solution of "PCA dimensionality reduction + normalization + random forest", which may simultaneously meet the target of 95% accuracy and 95MB model size, and quickly converge to the solution required by the task.

[0089] Based on the above embodiments describing the specifics of evolutionary memory banks and evolutionary memory systems, please also refer to... Figure 6 , Figure 6 A flowchart of a method for determining the current parent solution based on an improvement strategy, provided in this embodiment of the disclosure, includes the following steps in process 600: Step 601: Determine the selection weights of each annular strip constituting the link topology based on the improvement strategy; The purpose of this step is to determine the selection weights of each ring strip in the segmented topology based on the improved strategy. The calculation of the selection weights can be determined by several key factors. For example, the magnitude of the selection weight is directly proportional to the probability that a historical solution in the population is used as a historical parent solution to produce an effective solution, and the magnitude of the selected effective solution is directly proportional to the degree to which the produced effective solution meets the task requirements compared to the corresponding historical parent solution. The magnitude of the selection weights can also be directly proportional to the magnitude of the population entropy, and the magnitude of the population entropy is directly proportional to the degree of diversity of historical solutions in the population.

[0090] In the multi-population island parallel model, the historical solutions of each population are stored in a corresponding "circular strip" (e.g., the "PCA dimensionality reduction + random forest" series of solutions for "island 1" exists in "circular strip 1", and the "normalization + SVM" series of solutions for "island 2" exists in "circular strip 2"). The selection weight is the "priority score" assigned to each circular strip by the aforementioned execution entity, directly determining the probability of that strip being selected. When calculating the weight, three factors strongly correlated with "evolutionary efficiency" need to be considered: First, there's the "probability of generating valid solutions from historical solutions," which reflects the "historical reliability" of the population. For example, if the historical solution "PCA dimensionality reduction + random forest (n=50)" in ring strip 1 is used as a parent solution, and the generated child solutions (e.g., "n=100") meet the "valid solution" criterion of "accuracy improvement ≥2% compared to the parent solution" in 8 out of 10 iterations, then the "valid solution probability" for that strip is 80%. The higher the probability, the more "reliable" the historical solutions of that strip are, and the more likely they are to generate useful child solutions when used as parent solutions, thus resulting in a higher weight.

[0091] Secondly, there's the "degree of improvement of the effective solution to the task requirements," which reflects the population's "historical contribution." For example, when the historical solution "original features + XGBoost (max_depth=3)" in annular strip 3 is used as the parent solution, the generated effective solution "max_depth=5" not only improves the accuracy from 85% to 89% (meeting the requirements), but also reduces the model size from 120MB to 100MB (complying with the new size limit). The higher this degree of "multi-dimensional improvement," the greater the "potential" of the historical solutions in that strip, and the greater their weight.

[0092] Finally, there's "population entropy," which reflects the population's "evolutionary potential." Population entropy measures the "diversity" of historical solutions within the population. For example, solutions in ring strip 1 might include various strategies such as "PCA dimensionality reduction + random forest (n=50)" and "PCA dimensionality reduction + XGBoost (max_depth=4)," while solutions in ring strip 2 are mostly of a single type like "normalization + SVM (C=1)" and "normalization + SVM (C=2)." Therefore, strip 1 would have a higher population entropy (e.g., 0.8 out of a possible 1). Higher entropy indicates greater "diversity" in the population's solutions, preventing the evolutionary process from getting stuck in "local optima" (e.g., adjusting only one parameter) and preserving the possibility of exploring new strategies; thus, its weight will increase accordingly.

[0093] Step 602: Determine the segment with the highest selection weight as the target selection segment; Once the weights of all ring strips have been calculated, the aforementioned execution entity will select the strip with the highest weight as the "target selection strip," because it is the "most reliable, most contributing, and most promising" evolutionary starting point for the current round. For example, if the weight of ring strip 1 (considering the above three factors) is 0.65, strip 2 is 0.45, and strip 3 is 0.61, then strip 1 will be selected as the target strip.

[0094] Step 603: Select the current parent solution from the historical solutions stored in the target selection strip.

[0095] This step aims to select the historical solution that best fits the current improvement strategy from the target selection strip. For example, if the current improvement strategy is to "maintain feature engineering optimization (such as PCA dimensionality reduction) and adjust model parameters (such as n_estimators in random forest) to improve accuracy," then "PCA dimensionality reduction + random forest (n=100)" (93% accuracy, 95MB model size) in target strip 1 would be selected as the parent solution. It includes the proven and effective feature engineering method "PCA dimensionality reduction" and has room for adjustment in the "n_estimators" parameter (e.g., increasing it to 150), directly supporting the evolutionary needs of the current round. Furthermore, the elite solutions stored in the target selection strip can be determined as the current parent solution to increase the likelihood that the current parent solution will produce a better solution.

[0096] Taking the "XX flower classification task" as an example, suppose there are three annular bands (corresponding to three populations): Ring strip 1 (population 1): Stores a series of solutions of "PCA dimensionality reduction + random forest", with an effective solution probability of 80% (8 effective solutions are generated in 10 uses of the parent solution), and the accuracy of the effective solution is 3% higher than that of the parent solution on average. The population entropy is 0.8 (the diversity of solutions is high, with different n_estimators and max_depth values). Ring strip 2 (population 2): Stores a series of solutions with "normalization + SVM", with an effective solution probability of 60%, an accuracy improvement of 2%, and a population entropy of 0.5 (the solution type is singular, mostly involving adjusting the C parameter of SVM). Circular strip 3 (population 3): Stores a series of solutions with "original features + XGBoost", with an effective solution probability of 70%, an accuracy improvement of 4%, and a population entropy of 0.7 (moderate solution diversity).

[0097] After comprehensive calculation, strip 1 has the largest weight (0.65) and is selected as the target strip. The current improvement strategy is to "adjust the n_estimators of the random forest to improve accuracy". Therefore, "PCA dimensionality reduction + random forest (n=100)" (accuracy 93%, model size 95MB) in strip 1 is selected as the current parent solution. It contains effective feature engineering methods and has a clear parameter adjustment space, which can effectively promote the evolution of the current round.

[0098] This embodiment, through the scheme provided in steps 601-603, comprehensively evaluates the population's "historical performance" (effective probability, improvement level) and "evolutionary potential" (population entropy) to select the population that can best drive the current round of evolution, and then selects a parent solution that conforms to the improvement strategy from this population. This design allows the evolutionary agent to fully utilize reliable parent solutions while preserving diversity through population entropy, efficiently and robustly approximating the target solution required by the task. Just like when humans solve problems, they prioritize methods that have been effective in the past while trying new variations, ultimately finding the optimal solution.

[0099] To further understand how evolutionary experience is generated, in addition to any of the above embodiments, please refer to [link to relevant documentation]. Figure 7 , Figure 7 A flowchart of a method for generating evolutionary experience provided in this disclosure embodiment is included in process 700, comprising the following steps: Step 701: Determine the expected improvement based on the improvement strategy, and determine the actual improvement based on the actual degree to which the current solution meets the task requirements; Improvement expectations are quantitative goals set based on the current improvement strategy, acting as an evolutionary "compass." For example, if the strategy is to "increase the number of trees (n_estimators) in the random forest from 100 to 150 to improve accuracy," the expectation would be refined to "accuracy increase by at least 2% (core objective), model size increase by a maximum of 5MB (side effect control)." The former is the "core effect" of the strategy, while the latter is the "constraint that cannot be broken." Actual improvement, on the other hand, is the real change of the current solution relative to the parent solution, representing the "result feedback" of evolution. For example, if the parent solution is "n_estimators=100, accuracy 93%, model size 95MB," and the current solution is "n_estimators=150, accuracy 94.5%, model size 103MB," then the actual improvement would be "accuracy increased by 1.5% (reaching the expected 75%), and model size increased by 8MB (exceeding the constraint by 60%)."

[0100] Step 702: Determine the degree of matching based on the difference between the actual improvement and the expected improvement; Matching degree is the degree to which the actual improvement matches the expected improvement, used to determine whether a strategy is "effective." During calculation, each task dimension is evaluated separately, and then weighted and aggregated according to priority. For example, in the example above: Accuracy metrics: Actual increase of 1.5%, expected increase of 2%, matching degree is 1.5 / 2=75% (indicating that the strategy has an effect on improving accuracy, but has not fully achieved the target); Model size dimension: expected to increase by a maximum of 5MB, but actually increased by 8MB, with a matching accuracy of 5 / 8 = 62.5% (indicating that the side effects were not controlled); If the task prioritizes accuracy (weight 0.7) and model size (weight 0.3), the overall matching degree is 75%×0.7+62.5%×0.3=71.25% (indicating that the strategy is effective overall, but side effect control needs to be adjusted).

[0101] Step 703: Determine the positive and negative contributions based on the matching degree; Positive contributions are those improvements that meet or exceed expectations; they represent "successful experiences" in evolution. For example, the "1.5% increase in accuracy," while not reaching 2%, still represents an improvement and is therefore a positive contribution, indicating that the strategy of "increasing the number of trees" is effective. Negative contributions, on the other hand, are those that do not meet expectations or even worsen the situation; they represent "problematic shortcomings" in evolution. For example, an "8MB increase in model size," exceeding the expected 5MB, is a negative contribution, indicating that the strategy did not do a good job of "controlling model size." This step involves "summarizing lessons learned": maintaining what was done correctly and correcting what was done wrong to avoid repeating the same mistakes.

[0102] Step 704: Based on the positive and negative contributions, generate improvement suggestions for the current solution to at least maintain the positive contribution and to minimize the negative contribution as much as possible.

[0103] The improvement suggestions are action guidelines based on positive and negative contributions, with the core principle of "maintaining positive contributions and mitigating negative contributions." For example, in the example above, the suggestion might be: Maintain positive contribution: Continue to use the strategy of "increasing the number of trees", but adjust the value (for example, reduce it from 150 to 130) to retain the effect of improving accuracy while reducing the increase in model size (130 trees are smaller than 150 trees). To mitigate negative contributions, model compression techniques (such as pruning or quantization) can be used. Pruning can remove unimportant trees (such as trees that do not contribute to the prediction), and quantization can convert 32-bit floating-point numbers into 8-bit integers (reducing storage volume). In this way, the model size can be reduced from 103MB to 98MB (keeping it within the expected 5MB).

[0104] The key to improvement suggestions is their "targetedness." They don't blindly adjust all parameters but focus on the "successful parts" and the "problematic parts," making the evolution more efficient.

[0105] Taking the XX flower classification task as an example, suppose the improvement strategy is "to reduce the number of features from 4 to 2 using PCA dimensionality reduction, with an expected increase in accuracy of 1% and a reduction in model size of 10MB". The parent solution is "original features + random forest (n_estimators=100), accuracy of 92%, model size of 110MB". The current solution is "PCA dimensionality reduction + random forest (n_estimators=100), accuracy of 93%, model size of 95MB".

[0106] Expected Improvement: Accuracy +1%, Model Size -10MB; Actual Improvement: Accuracy increased by exactly 1% (meeting the target), Model Size decreased by 15MB (exceeding expectations); Matching Degree: Accuracy 100%, Model Size 150% (overall 120%, indicating the strategy is very effective); Positive Contribution: Both accuracy and model size met the target; Improvement Suggestion: Maintain the current strategy (PCA dimensionality reduction + n_estimators=100), as it fully met the expectations and no adjustment is needed.

[0107] For example, if the current solution is "PCA dimensionality reduction + random forest (n_estimators=150), accuracy 93.5%, model size 105MB", and the actual improvement is "accuracy increased by 1.5% (exceeding expectations), model size decreased by 5MB (not meeting the target)". In this case, the positive contribution is "accuracy improvement", and the negative contribution is "model size not reduced enough". A suggestion might be: maintain PCA dimensionality reduction (positive), reduce n_estimators from 150 to 120 (reduce the number of trees, reduce model size), and then use pruning techniques (remove unimportant trees) to reduce the model size from 105MB to 95MB (achieving the expected 10MB reduction).

[0108] This embodiment provides a specific implementation method for generating evolutionary experience through steps 701 to 704. Essentially, it compares expected improvements with actual improvements, breaks down "effective actions" and "ineffective / negative actions" in the evolutionary process, and generates targeted improvement suggestions, providing a clear direction for strategy adjustments in subsequent evolutionary rounds. This process retains "successful experiences" (positive contributions) while avoiding the repetition of "failure lessons" (negative contributions), and is a key driver of the "spiral upward" evolutionary process.

[0109] Based on the above embodiments, considering that the solutions generated may sometimes contain unexpected situations or behaviors, in such cases, when the current solution contains unexpected behaviors that exceed the improvement expectations, the improvement suggestions can be adjusted based on the unexpected behaviors, so that the unexpected behaviors generated can also be included as part of the experience through the adjusted improvement suggestions.

[0110] Unexpected performance refers to unforeseen changes in the current solution that exceed the improvement expectations but are relevant to the task requirements. These can be categorized into "positive surprises" (providing additional gains to the task) and "negative surprises" (having unexpected side effects). Their common characteristic is that they are "not part of the core objectives of the improvement plan, but affect the overall performance of the task." For example, a positive surprise: Suppose the improvement strategy is to "increase the number of trees in the random forest (n_estimators) from 100 to 150, with an expected accuracy increase of 2%." The result is not only that the accuracy increases from 93% to 95.5% (meeting expectations), but it also unexpectedly narrows the accuracy gap between the validation set and the training set from 8% to 5%, reducing overfitting. Although not mentioned in the improvement plan, this greatly helps the model's generalization ability. A negative surprise: If the improvement strategy is to "increase the learning rate of the neural network from 0.001 to 0.01, with an expected accuracy increase of 1%," the result is that the accuracy increases from 88% to 89% (meeting expectations), but the model convergence time increases from 10 epochs to 20 epochs. This increases training time and is an unplanned side effect, affecting training efficiency.

[0111] These unexpected results are important because evolutionary strategies often focus on "core objectives" (such as accuracy), but the actual results may produce unexpected changes in "secondary objectives" (such as overfitting and training time). These changes may contain "better parameter combinations" (such as adjusting the number of trees in a positive surprise) or "traps to avoid" (such as an excessively high learning rate in a negative surprise). Capturing them allows the agent to accumulate experience more comprehensively.

[0112] When unexpected behavior is detected, the aforementioned implementing entity can transform the "unexpected" into reusable experience through three steps: First, assess the impact of the unexpected event: determine whether it is positive or negative, and quantify its contribution to the task. For example, a positive unexpected event like "reducing the gap between the validation set and the training set by 3%" significantly improves the "model's generalization ability." A negative unexpected event like "increasing convergence time by 10 epochs" has a significant negative impact on "training efficiency." Next, analyze the causes of the unexpected event: trace back the generation process of the current solution to identify the key factors leading to the unexpected event. For example, an "increased number of trees" in a positive unexpected event might be because more trees make the model's predictions more stable, thus reducing overfitting. A negative unexpected event like "excessively high learning rate" might be because a large learning rate causes model oscillations, requiring more time to converge. Finally, adjust the improvement suggestions: integrate the causes and impacts of the unexpected event into the original suggestions. For example, in the case of positive unexpected events, the original suggestion was to "keep the number of trees at 150 to improve accuracy". After adjustment, it will become "keep the number of trees at 150, and try to increase the maximum depth of the trees (max_depth) from the default value to 8. This can further limit the complexity of the trees and enhance the improvement of overfitting". In the case of negative unexpected events, the original suggestion was to "keep the learning rate at 0.01 to improve accuracy". After adjustment, it will become "keep the learning rate at 0.01, and increase the batch size (batch size) from 32 to 64. A larger batch can reduce gradient oscillations and shorten the convergence time".

[0113] After this adjustment, unexpected performance is no longer a "chance occurrence" but a "replicable experience". When encountering similar situations in the future, the agent can directly call on these experiences. For example, when it needs to improve generalization ability, it will think of "increasing the number of trees and adjusting the maximum depth"; when it needs to speed up training, it will avoid "excessively high learning rates".

[0114] For example, in a flower classification task, suppose the improvement strategy is "to reduce the number of features from 4 to 2 using PCA dimensionality reduction, with an expected accuracy increase of 1%." The result is not only an increase in accuracy from 92% to 93% (meeting expectations), but also an unexpected reduction in model inference time from 0.1 seconds / sample to 0.05 seconds / sample (a positive surprise). In this case, the agent would analyze the reason (PCA dimensionality reduction reduces the number of features, thus reducing computational cost) and suggest adjusting to "maintaining PCA dimensionality reduction while trying more efficient dimensionality reduction methods (such as t-SNE) to further shorten inference time." In this way, the unexpected performance of "shortening inference time" becomes experience. When future deployment efficiency needs improvement, the agent can directly utilize this experience to find a better solution.

[0115] The adjustment scheme for capturing and improving unexpected performance provided in this embodiment is a mechanism for learning from unexpected events. Essentially, it simulates the human mindset in dealing with unforeseen situations. That is, when we do something, we may encounter results beyond our plans (for example, we originally intended to improve work efficiency, but it ended up improving team communication). In this case, we proactively analyze the reasons, adjust our behavior, and turn the unexpected into experience. For evolutionary intelligent agents, this mechanism allows them to more comprehensively "learn" various signals during the evolutionary process, not just limited to pre-set goals.

[0116] Based on the above embodiments, to deepen the understanding of how to summarize different evolutionary experiences generated from different historical solutions at different historical evolutionary stages, this embodiment also provides a specific implementation method: First, identify parent-child historical solutions with parent-child relationships among different historical solutions, and generate a summary of parent-child solution evolutionary experiences based on the differences between the different evolutionary experiences corresponding to the parent-child historical solutions. Then, identify different child historical solutions corresponding to the same parent historical solution among different historical solutions, and generate a summary of parallel child solution evolutionary experiences based on the differences between the evolutionary experiences corresponding to each child historical solution in a parallel relationship. The historical evolutionary experience summary includes: the parent-child solution evolutionary experience summary and the parallel child solution evolutionary experience summary.

[0117] Parent-child historical solutions are solutions with a direct inheritance relationship in the evolutionary process: the parent solution is the "foundation for the generation of the child solution," and the child solution is the "result of the parent solution after parameter adjustment or strategy optimization." For example, the parent solution is "using PCA dimensionality reduction + random forest model (number of trees n_estimators=100), accuracy 93%, model size 95MB," and the child solution is "also using PCA dimensionality reduction + random forest, but increasing the number of trees to 150, resulting in an accuracy improvement to 95%, and the model size becoming 103MB." Here, the child solution inherits the "core strategy" (PCA dimensionality reduction + random forest) of the parent solution, only adjusting the "number of trees" parameter, thus forming a "parent-child relationship." Evolutionary experience differences are the quantitative changes of the child solution relative to the parent solution, including "improvements in the core objective" (such as a 2% increase in accuracy) and "changes in side effects" (such as an 8MB increase in model size). These differences are "direct feedback on the evolutionary effect," telling us "what exactly happened after adjusting a certain parameter." The summary of parent-child solution experience is the extraction of patterns from these "differences." For example, the above case can be summarized as follows: "Under the 'PCA dimensionality reduction + random forest' strategy, increasing the number of trees (n_estimators) can significantly improve accuracy, but it will be accompanied by an increase in model size." The value of this summary lies in transforming "specific parameter adjustments" into "reusable rules." If a task arises where "improvement in accuracy is required and an increase in model size is acceptable," the agent can directly invoke this rule and prioritize the strategy of "increasing the number of trees" without having to try other parameters from scratch.

[0118] Parallel sub-historical solutions are different sub-solutions generated from the same parent solution. They all originate from the same "parent solution base" but have different adjusted parameters or strategies, thus belonging to the "parallel relationship". For example, still using the parent solution above (PCA + Random Forest n=100), besides sub-solution 1 (n=150), there is also sub-solution 2: "Increasing the maximum tree depth (max_depth) from the default value to 8 results in an accuracy increase of 94%, while maintaining the model size at 95MB, but reducing the generalization ability (the difference in accuracy between the validation set and the training set) from 8% to 5%". Here, sub-solution 1 and sub-solution 2 are both "descendants" of the parent solution, but they adjust different parameters (one adjusts the number of trees, and the other adjusts the tree depth), thus forming a "parallel relationship". Evolutionary experience differences are the differences in effects between these parallel sub-solutions. For example, sub-solution 1 has "greater accuracy improvement (+2% vs. +1%)" but "greater model size increase (+8MB vs. 0%)", while sub-solution 2 has "more significant improvement in generalization ability (from 8% to 5% vs. from 8% to 7%)" and "the model size remains unchanged". These differences tell us the advantages and disadvantages of different adjustment directions. The summary of parallel sub-solution experiences is the extraction of patterns from these differences. For example, in the above case, the summary would be: "Adjusting the number of trees (n_estimators) is suitable for scenarios where 'accuracy is prioritized,' while adjusting the tree depth (max_depth) is suitable for scenarios where 'accuracy and generalization ability are balanced.'" The value of this summary lies in providing "scenario-based strategy selection" for "different task requirements." If the task requires "rapidly improving accuracy," then choose sub-solution 1; if the task requires "improving generalization ability without increasing model size," then choose sub-solution 2.

[0119] To make these concepts more concrete, let's take "XX flower classification task" as an example again: Parent solution A: PCA dimensionality reduction + random forest (n_estimators=100), accuracy 93%, model size 95MB, generalization ability (validation set - training set accuracy) 8%; Child solution A1 (child solution of parent solution A): Adjusting n_estimators=150, accuracy 95%, model size 103MB, generalization ability 7%; Child solution A2 (child solution of parent solution A): Adjust max_depth=8, accuracy 94%, model size 95MB, generalization ability 5%.

[0120] Summary of parent-child solution experience (parent solution A and child solution A1): "From parent solution A to child solution A1, increasing the number of trees (n_estimators) improved accuracy by 2% (from 93% to 95%), but increased the model size by 8MB (from 95MB to 103MB), with a slight improvement in generalization ability (from 8% to 7%). In conclusion: Under the 'PCA + Random Forest' strategy, increasing the number of trees can effectively improve accuracy, but it will lead to a larger model size."

[0121] Summary of experience with parallel sub-solutions (sub-solution A1 and sub-solution A2): "Sub-solution A1 (adjusting the number of trees) and sub-solution A2 (adjusting the tree depth) both originate from parent solution A. Sub-solution A1 shows a more significant improvement in accuracy (+2% vs. +1%), but the model size increases more (+8MB vs. 0); sub-solution A2 shows a more significant improvement in generalization ability (from 8% to 5% vs. from 8% to 7%), while the model size remains unchanged. In conclusion: adjusting the number of trees is suitable for scenarios where accuracy is prioritized, while adjusting the tree depth is suitable for scenarios that balance accuracy and generalization ability."

[0122] The solution provided in this embodiment describes how the essence of summarizing historical evolutionary experience is to transform specific historical solutions into abstract evolutionary laws. Specifically, parent-child solution summaries capture the improvement patterns in inheritance, answering the question of what adjusting a certain parameter will bring; parallel child solution summaries capture the advantages and disadvantages of different exploration directions, answering which adjustment direction is more suitable for the current task. These laws are like an evolutionary instruction manual, allowing the agent to move purposefully in subsequent evolution: when accuracy needs to be improved, it knows which parameter to adjust; when generalization ability needs to be balanced, it knows which direction to choose. This mechanism shifts the learning of the evolutionary agent from experience-driven to law-driven, significantly reducing the number of blind trial and error attempts and improving evolutionary efficiency.

[0123] To enhance understanding, this disclosure also attempts to provide a complete implementation solution, starting from some specific shortcomings of existing technologies: Achieving autonomous optimization in an open and high-dimensional machine learning task space presents core challenges in the "explosion of the search space" and the "fragility of end-to-end generation." Traditional large models often face severe context loss, illusions, and cascading errors that are difficult to debug when attempting to generate a complete and complex machine learning pipeline in one go. These problems are further amplified in scenarios requiring iterative evolution, as even small unstructured mutations can lead to catastrophic failure of the entire pipeline.

[0124] To address this fundamental challenge, this embodiment proposes a domain-adaptive structured decomposition design approach. This approach treats the machine learning solution space not as a chaotic code space, but as an ordered system composed of functionally orthogonal, clearly defined modules. Furthermore, a robust and evolvable machine learning agent requires a standardized workflow abstraction. This abstraction must be both general enough to cover the vast majority of machine learning tasks and specific enough to support rigorous modular verification and independent evolutionary mutations. Based on this, this embodiment constructs a deeply customized evolutionary framework (hereinafter referred to as the X framework) and develops a machine learning evolutionary agent based on this framework. This agent explicitly operates and evolves around a carefully designed six-stage paradigm.

[0125] Figure 8-1 The diagram illustrates the structure of the X framework, which adopts a layered and modular architecture. Based on the domain of abstraction and generality, the framework is divided from bottom to top into a Component Layer, a Framework Layer, and an Application Layer. Component Layer: Serving as the foundation of the entire framework, this layer provides general-purpose basic components for agent development. These components employ a strictly modular design, exhibiting low coupling and high cohesion, facilitating flexible expansion and integration. These include: Model (Model Components): Contains LLM (Large Language Model), Embedding (Embedding Model, converting text to vectors), and Formatter (Formatter, unifying input and output formats); Memory (Memory Components): Contains evolve_mem (Evolutionary Memory, storing the evolutionary hierarchy), and grade_mem (Graded Memory, managing the flow of STM / MTM / LTM); Tools (Tool Components): Contains func_tool (Function Tools, such as mathematical calculations and file operations), Agent_tool (Agent Tools, such as calling other agents), and Toolkit (Toolkit, an entry point for integrating various tools); Message (Message Components): Contains message (basic message structure), token (Token management, calculating context length), and msg_hub (Message Hub, routing messages from different modules); Observability (Observability Components): Contains logger (Logger, recording agent behavior), and tracing (Tracer, tracking task execution trajectories).

[0126] Framework layer: For the development of intelligent agents with different working paradigms, it provides development frameworks for the main paradigms of intelligent agents. By pre-setting different paradigm development frameworks in a modular way, it reduces the complexity of developing a single intelligent agent, while facilitating the flexible combination of different paradigms to develop complex intelligent agents that integrate multiple paradigms. These include: Evolve Paradigm: corresponding to EvolveAgent, whose core components include: Planner (generates evolutionary strategies), Executor (generates and verifies solutions), Evaluator (calculates the fitness of solutions), Summary (summarizes experience), Finalizer (determines the termination of evolution), and Database (stores evolutionary data); ReAct Paradigm: corresponding to ReActAgent, whose core components include: Reasoner (generates logic chains), Actor (executes tool calls), Toolkit (provides usable tools), Context (saves interaction history), Observer (monitors action results), and Finalizer (determines task completion); and BaseAgent: the underlying abstraction of all agents, supporting hooks (inserting custom logic) and interrupts (handling exceptional situations).

[0127] Application Layer: Based on the fundamental capabilities provided by the component and framework layers, this layer develops high-quality, ready-to-use intelligent agents for typical, challenging evolutionary task application scenarios, while simultaneously validating the effectiveness of the framework and components. Specifically: Machine Learning Evolutionary Intelligent Agent: For machine learning tasks, this layer provides mi-planner, mi-executor, and mi-summary, adapting to a six-stage process.

[0128] At the component layer, a series of atomic components are provided to support the basic capabilities required for agent development. These components can be flexibly integrated and used while supporting the construction of the X framework. Common components for agent development, such as Model, Memory, Tools, Message, and Observability, are provided to meet core requirements in the process of building evolutionary agents, including large model invocation and parsing, context memory management, tool implementation and pre-configuration, unified message format, and observability. In other words, the X framework, through its highly layered and modular architecture, allows for flexible selection of building blocks, like Lego bricks, to build high-quality evolutionary agents for various problem scenarios. It provides comprehensive coverage, from high-quality atomic components to innovative paradigm agent development frameworks for effect verification, and agents for highly complex task scenarios, flexibly meeting the needs of developers at all levels.

[0129] The design concept of this machine learning evolutionary agent is to distill the complex machine learning lifecycle into six atomic and functionally independent stages. This structured division is not only for engineering convenience, but also a key state-space constraint for achieving efficient search within the evolutionary computation framework.

[0130] By clearly defining stage boundaries, this ensures that evolutionary mutation operations are confined to specific functional subspaces. For example, changing feature engineering strategies should not compromise the integrity of the downstream model training code. This decoupling significantly reduces the probability of lethal mutations and improves the efficiency of evolutionary exploration. The six normalization stages defined in this architecture are as follows: 1. Data loading and standardization As the cornerstone of the pipeline, this stage is responsible for handling the reading, basic cleaning, and uniform formatting of multimodal raw data to ensure that subsequent processes have a stable and consistent data input.

[0131] 2. Definition of Evaluation Strategy

[0132] This stage is independent of model training and is specifically designed for designing rigorous validation protocols (such as hierarchical K-fold and time series segmentation). By abstracting and fixing the evaluation strategy stage, it ensures that there are reliable fitness signals during the evolutionary process and that data leakage does not occur, thereby effectively preventing the agent from overfitting to the wrong validation set.

[0133] 3. Feature Learning and Transformation

[0134] This is the most creative phase, involving high-dimensional feature engineering and spatial transformations. By isolating this phase, the agent can focus on exploring different data views and interactions without being constrained by a specific model.

[0135] 4. Model Training and Prediction

[0136] This stage focuses on model selection, hyperparameter optimization, and final inference computation. It is the core computational engine that maps data representations to target variables.

[0137] 5. Model Combination

[0138] As a meta-optimization stage, it is responsible for integrating multiple heterogeneous models generated in previous stages. This design explicitly supports advanced strategies in evolutionary algorithms that leverage population diversity to improve final performance.

[0139] 6. Pipeline assembly and delivery

[0140] The final stage is responsible for connecting all the above independent modules into an end-to-end executable flow and ensuring that the final output format meets the task requirements, completing the last mile closed loop from component to solution.

[0141] This six-stage paradigm forms the basic scaffolding for intelligent agents to reason, operate, and evolve.

[0142] Based on the above structured paradigm, this embodiment designs a composite intelligent agent system comprising three specialized roles for specific orchestration and execution. For example... Figure 8-2 As shown, these roles do not operate in isolation, but rather work collaboratively within a six-stage structure to jointly complete the transformation from abstract strategy to concrete implementation. (See also...) Figure 8-2 : 1. Planner Starting with parent solutions from the evolutionary environment, the planner combines embedded domain expert prior knowledge (such as exploration rules aimed at breaking performance stagnation or integration and utilization rules pursuing state-of-the-art (SOTA) performance). Based on these inputs, the planner performs long-range inference. For each of the six stages, a high-level natural language blueprint is generated. This structure-based planning approach ensures that the generated solution remains complete and logically sound at the macro level, effectively avoiding structural errors.

[0143] 2. Executor

[0144] It is responsible for translating the planner's semantic blueprint into entity code. It strictly follows a six-stage sequence, employing a divide-and-conquer strategy to break down the complex pipeline construction task into six independent subtasks. For each stage, it not only calls the LLM to generate code, but more importantly, it introduces a mandatory verification mechanism of "stage-level input / output evaluation." Only when the code generated by a stage successfully runs and passes its specific data manifold constraints and logical consistency checks will it proceed to the next stage. This mechanism constitutes an evolutionary "quality filter," fundamentally ensuring the robustness of the final assembled complex pipeline.

[0145] 3. Summary

[0146] Intervening after the entire pipeline has been completed, it forms a crucial feedback loop in the evolutionary learning process. Unlike traditional evaluation methods that only provide a single scalar score, Summary performs cross-stage attribution analysis. It comprehensively examines the Planner's original intent, the Executor's specific implementation trajectory, and the final performance to identify the key structural factors leading to the current result.

[0147] The Summary ultimately generates a structured strategic analysis briefing, which is essentially a high-dimensional qualitative evaluation of the current six-stage configuration. It provides the next generation of Planners with a clear gradient direction on how to adjust strategies for specific stages, thereby significantly improving the sample efficiency of evolution.

[0148] For the overall system execution flow, please refer to Figure 8-3 : Planner: Samples from evolutionary databases, analyzes task description files, performs EDA analysis on the provided dataset, plans tasks for each stage of machine learning, and generates a plan that includes instructions for all subsequent stages. Executor: Generates code through multiple standardized stages, and executes and evaluates the code according to pre-injectable and flexible rules. It can be further divided into: 1) Data Loading: Analyze the task description, parse out the original data path, and return a dataset in a unified format; 2) Cross-Validation: Select a suitable cross-validation strategy based on data characteristics (such as task type, label distribution, etc.); 3) Feature Engineering: Create and transform features for the data; 4) Model Training and Prediction: Train and predict the model; 5) Ensemble Learning: Collect the prediction results of one or more models and execute the ensemble strategy to generate the final test set; 6) Workflow: Assemble the final test files and generate a dataset that conforms to the specified format.

[0149] Task execution: Execute the code generated in the previous six stages and obtain the results; Evaluation: Implement task evaluation and scoring through a predefined evaluation interface.

[0150] Summary: The task is summarized, the results are stored in the database, and operations such as weighting are performed.

[0151] In agent frameworks designed for evolution in general algorithmic tasks, the memory module not only needs to process massive amounts of interaction data but also needs to maintain long-term coherence under the constraints of a limited LLM context window. Traditional single-memory storage schemes struggle to simultaneously meet the high-fidelity requirements of short-term interactions and the persistence requirements of long-term knowledge.

[0152] To address this, the X framework also proposes a hierarchical memory architecture based on protocol abstraction. The core design of this architecture lies in completely decoupling the logical control, state detection, and information compression of memory from the underlying storage modules. By defining standardized interface specifications, it achieves high system scalability and service pluggability.

[0153] The overall system architecture is as follows: Figure 8-4 As shown, from top to bottom, it is divided into control layer, memory layer, and protocol layer: Control Layer: The core is the GradeMemory controller, which is the central hub of the entire memory system. The controller is responsible for coordinating data read / write requests, executing hierarchical strategies, and triggering memory consolidation processes. To precisely manage context windows, the control plane uses a separate Token counter service to monitor token consumption at each level of memory in real time and make decisions to ensure that the Agent always operates within a safe context.

[0154] Memory layer: Information is managed in layers based on its timeliness, fidelity, and persistence requirements. Immediate Short-Term Memory: Stores the most recent original conversation content, emphasizing high fidelity and real-time performance; Mid-term contextual memory: Stores compressed contextual summaries, acting as a bridge linking short-term memory interactions and long-term knowledge, balancing contextual integrity with token consumption; Long-term semantic memory: mainly realizes persistent knowledge management, stores factual information across sessions, and usually connects to a vector database with semantic retrieval capabilities.

[0155] Protocol Layer: Implements storage media-independent data storage capabilities and customizable information compression capabilities, including: 1) Unified Storage Interface: Standardized data operation and search capabilities. Any implementation conforming to the specification, such as memory-based InMemoryStorage, file-based data storage, or semantic retrieval engines based on vector databases, can be injected into different memory layers at runtime; 2) Compression Abstraction Strategy: Abstracts memory compression algorithms through the Compressor interface, allowing developers to flexibly connect different compression strategies, such as simple truncation strategies or LLM-based generative compression.

[0156] Based on the above architecture, an automated memory transfer mechanism was also implemented; please refer to [link / reference]. Figure 8-5 When a new message arrives, the controller first requests the token counter to calculate the current total number of tokens. Once the accumulated context length exceeds a preset threshold, the system automatically triggers a memory compression and integration process: first, it aggregates the original messages in the medium and short-term memories, extracts them into a semantic digest using a custom compressor, then clears the current medium and short-term memories, and saves the digest to the medium-term memory. This mechanism ensures that the Agent can continue to operate efficiently within a limited token budget.

[0157] Furthermore, in the evolution of AI agents, the effective management and utilization of historical experience is a key factor determining evolutionary efficiency. The main challenges faced by traditional evolutionary algorithms include: 1) Premature convergence and the trap of local optima: A single population structure is prone to convergence to a local optimum within a finite number of iterations due to overexploitation. While elite preservation strategies protect high-quality solutions, they also accelerate population homogenization and suppress key innovative mutations. 2) Difficulty in reusing valuable historical experience: Successful experiences and lessons learned during the evolutionary process are difficult to systematically preserve and reuse, leading to high repetition in population evolution, suppressing the possibility of innovative breakthroughs, and wasting computational resources. 3) The dynamic balance problem of exploration-exploitation: The system struggles to dynamically adjust the search pressure based on the population state at different stages of the search. Overemphasizing fitness can lead to population aggregation, while overemphasizing diversity may reduce search efficiency and waste computational resources.

[0158] To address these issues, this embodiment also proposes an innovative "Evolutionary Memory System," which deeply integrates a multi-island parallel model, the MAP-Elites elite archiving algorithm, and an adaptive Boltzmann selection mechanism within the X framework. By structuring historical experience into a self-organizing memory network, this architecture effectively solves the problems of premature convergence and knowledge forgetting in populations.

[0159] This evolutionary memory system employs a hierarchical modular design (see below). Figure 8-6 This system aims to achieve highly cohesive and loosely coupled memory management. It consists of an application layer, a core implementation layer, and a data storage layer. The core implementation layer supports the continuous evolution of the agent through four sub-modules: the "MAP-Elites Manager," the "Multi-Island Manager," the "Boltzmann Selector," and the "Feature Calculation Module." The core components are described in detail below: 1. Multi-island adaptive parallel mechanism This evolutionary memory system employs a multi-island parallel architecture, dividing the total population into N independent subpopulations (islands). The islands are connected by a ring topology, effectively preventing premature homogenization by limiting the frequency and scale of migrations. Each island maintains an independent optimal solution and feature map to achieve fine-grained state management. This approach offers two advantages: enhanced parallelism: different islands can simultaneously search different regions of the solution space, significantly improving search breadth; and improved robustness: performance degradation or local optima traps on a single island do not rapidly spread to the entire system.

[0160] In addition, intelligent migration strategies between multiple islands enable the integration and synergy of different population algorithms, stimulating continuous evolutionary innovation. The migration mechanism is no longer based on fixed time intervals, but rather adaptively triggered based on the state differences between islands (such as capacity differences and diversity differences). The migration process follows the logic below (see below). Figure 8-7 ): 1) Source selection: Select the top 20% of elite solutions in terms of fitness from the source islands; 2) Deduplication detection: Perform content hash matching on the target island to prevent invalid migration of duplicate solutions; 3) Topology: A ring topology is used to promote the unidirectional flow of genes between different islands and maximize differentiated development.

[0161] 2. Deep integration of MAP-Elites

[0162] This system uses MAP-Elites as the core component for diversity maintenance. The system maps each solution to a multi-dimensional feature space, with typical feature dimensions F including: f1: Complexity, based on the length of the solution or the depth of the structure; f2: Diversity, based on a measure of difference from the reference set; f3: Score, based on the fitness of the objective function; For any solution x, its coordinates C(x) in the feature grid are determined by the following equation: C(x) = bin(f1(x)),bin(f2(x)),…,bin(fn(x)) The bin() function dynamically adjusts the boundaries based on the statistical distribution of eigenvalues. Each grid cell (i,j,k) retains only the solution with the highest fitness at that location, ensuring that each region in the feature space is occupied by the optimal individual.

[0163] 3. Adaptive Boltzmann Selection Based on Diversity

[0164] To achieve a balance between "exploration" and "expitation," the system incorporates an adaptive temperature control Boltzmann selection mechanism.

[0165] The specific process steps can be as follows: 1) Input population state: Receive the current population state S (such as population size, feature distribution, fitness score); 2) Calculate population diversity: Calculate population entropy H(P) (an indicator of population diversity; the larger H(P) is, the higher the diversity). 3) Determine the diversity threshold: If H(P) is higher than the threshold (e.g., H(P)>0.8), it indicates high population diversity. Lower the temperature τ (e.g., τ=0.1) to encourage utilization (greedy selection, prioritizing individuals with high scores); if H(P) is lower than the threshold (e.g., H(P)<0.5), it indicates population convergence. Increase the temperature τ (e.g., τ=1.0) to promote exploration (random selection, prioritizing novel individuals). 4) Calculate the Boltzmann probability: For each individual i, calculate the probability P(i) of being selected (based on temperature τ and fitness score); 5) Normalization and sampling: Normalize the probability (ensure the sum is 1) and use Roulette Wheel Selection to select the parent individual (e.g., select the individual with the highest probability as the parent).

[0166] In hybrid evolutionary memory systems, a key failure mode for evolutionary agents is premature convergence, where the population gets trapped in a single local optimum, thus hindering innovation. The X framework addresses this issue through a multi-layered memory architecture: 1. Multi-island distributed topology Single-population models are prone to generating "advantages," where a successful strategy outperforms all others, thus eliminating genetic diversity. The X framework employs a multi-island model with a ring topology. The population is divided into N isolated islands. Each island evolves independently, allowing for the development of different algorithmic "species." Migration occurs only when the diversity difference ΔD between adjacent islands exceeds a threshold. The top k% of elite individuals are replicated to adjacent islands as "invasive species" to break stagnation. This spatial isolation ensures the maintenance of global diversity. It enables the system to explore multiple disjoint attraction basins simultaneously, preventing the system from getting trapped in a single local optimum.

[0167] 2. MAP-Elites with Featured Mesh

[0168] Objective-based selection (ranking solely by score) often overlooks novel but insufficiently refined solutions ("stepping stones") that are essential for reaching the global optimum. Within each island, the X framework utilizes a MAP-Elites (phenotypic multidimensional archive) container. Solutions are mapped to a feature grid A based on behavioral descriptors Φ(s) (e.g., code complexity × memory usage). The system preserves the best individual for each cell in the grid, not just the global optimum. This guarantees niche preservation. A "slow but highly concise" solution is not superseded by a "fast but verbose" one. This provides the planner with a diverse "gene pool" for cross-pollination.

[0169] 3. Adaptive Boltzmann Selection

[0170] The balance between exploration and exploitation is dynamic. Fixed hyperparameters (such as a fixed mutation rate) inevitably lead to inefficiencies at different stages of evolution. The X framework implements entropy-regularized Boltzmann selection. The selection temperature τ is dynamically adjusted based on the population entropy H(P). τ(t) ∝ exp(-λ·H(Pt)). When the population has diversity (high H), the value of τ decreases to encourage exploitation (greedy). When the population converges (low H), the value of τ increases to promote exploration (stochastic). This achieves adaptive control. The system automatically switches between "finding new ideas" and "refining existing ideas" without human intervention.

[0171] Further reference Figure 9 As an implementation of the methods shown in the above figures, this disclosure provides an embodiment of a complex problem processing device based on evolutionary agents. This device embodiment is similar to... Figure 2 Corresponding to the method embodiments shown, this device can be specifically applied to various electronic devices.

[0172] like Figure 9 As shown, the complex problem processing device 500 based on evolutionary intelligent agents in this embodiment may include: an evolutionary solving unit 901 and a repetitive execution unit 902. The evolutionary solving unit 901 is configured to determine the task requirements and current evolutionary round of the complex problem to be processed, and execute the evolutionary solving steps as follows: based on a task requirement and a summary of historical evolutionary experience, a multi-stage improvement strategy is determined for the current evolutionary round compared to the previous evolutionary round. The summary of historical evolutionary experience is obtained by summarizing different evolutionary experiences generated from different historical solutions in different historical evolutionary rounds. Based on the multi-stage improvement strategy, a multi-stage sub-task for processing the complex problem to be processed is generated, and each stage sub-task is executed sequentially to obtain the current solution. In response to a current solution not meeting a task requirement, based on the multi-stage improvement strategy and the actual degree to which the current solution meets the task requirement, evolutionary experience with evolutionary orientation corresponding to the current evolutionary round is generated. The summary of historical evolutionary experience is updated using the evolutionary experience of the current evolutionary round. The repeat execution unit 902 is configured to take the next evolutionary round as the new current evolutionary round and repeat the evolutionary solving steps until a target solution that meets the task requirement is obtained.

[0173] In this embodiment, the specific processing of the evolutionary solving unit 901 and the repeated execution unit 902 in the complex problem processing device 900 based on evolutionary intelligent agents, and the resulting technical effects, can be found in reference to [reference needed]. Figure 2 The relevant descriptions of steps 201-203 in the corresponding embodiments will not be repeated here.

[0174] In some other alternative implementations of this example, an evolutionary solving unit 901 includes a current solution generating subunit configured to generate multi-stage subtasks for processing a complex problem based on a multi-stage improvement strategy, and to sequentially execute each stage subtask to obtain the current solution. A current solution generating subunit includes: The current parent solution selection module is configured to select the current parent solution from the memory evolution library that stores all historical solutions based on a multi-stage improvement strategy; The multi-stage subtask generation module is configured to generate multi-stage subtasks for handling a complex problem to be addressed, based on a current parent solution, a task requirement, and a multi-stage improvement strategy. The sequential execution module is configured to execute the subtasks of each stage in sequence, and determine the task execution result of the last stage's subtask as a current solution.

[0175] In some other alternative implementations of this example, a multi-stage improvement strategy and its corresponding multi-stage subtasks both include the following multiple task processing stages arranged in sequence: Loading data, cross-validation, feature engineering, model training and prediction, ensemble learning, and workflow encapsulation and integration.

[0176] In some other alternative implementations of this example, the multi-stage subtask generation module also includes: The temporary stage subtask generation submodule is configured to generate a temporary stage subtask in response to a task requirement for a complex problem to be addressed that includes personalized requirements. The temporary insertion position determination submodule is configured to determine the temporary insertion position of a temporary stage subtask among multiple existing stage subtasks. The position-insertion submodule is configured to insert a temporary stage subtask into an existing sequence of multiple stage subtasks at a temporary insertion position, so that the stage subtasks are executed sequentially according to the order of the execution sequence.

[0177] In some other alternative implementations of this example, sequential execution of modules also includes: The subtask verification set determination submodule is configured to determine the subtask verification set corresponding to the executed stage subtask after each stage subtask is executed; wherein, a subtask verification set is generated based on the stage improvement strategy corresponding to the corresponding stage subtask; The verification processing submodule is configured to verify the task execution status of the corresponding stage subtask using a subtask verification set, and only continue to execute the next stage subtask after the verification is passed.

[0178] In some other alternative implementations of this example, sequential execution of modules also includes: The verification failure handling submodule is configured to respond to any stage subtask failing verification by regenerating the corresponding stage subtask based on the verification failure feedback until verification is passed or the number of retries exceeds a preset number, then return an error message and terminate other unexecuted stage subtasks.

[0179] In some other alternative implementations of this example, the complex problem-solving apparatus 900 based on evolutionary agents also includes: The transient memory storage unit is configured to store the contents generated during the execution of an evolutionary solution step as transient memory; The intermediate memory update unit is configured to aggregate all currently accumulated instantaneous memories and historical intermediate memories in response to the cumulative storage of instantaneous memories exceeding the preset upper limit of the amount of preceding information, and generate a semantic summary for the aggregation result as a new intermediate memory. The long-term memory transfer unit is configured to transfer intermediate memories that have been retained more than a preset number of times and / or whose importance exceeds a preset level into long-term memories; wherein, a momentary memory, an intermediate memory, and a long-term memory are associated with the corresponding historical solutions.

[0180] In some other alternative implementations of this example, an evolutionary memory bank uses a tree diagram to record all historical solutions. The evolutionary memory bank is a memory storage unit in an evolutionary memory system based on a multi-population island parallel model and a multi-dimensional phenotypic elite archiving algorithm. The structure of the multi-population island parallel model is a ring topology. The ring topology is obtained by splicing ring strips corresponding to the number of islands. Each ring strip is used to store the historical solutions belonging to the corresponding population stored on the corresponding island. The elite solutions of each population are recorded by a multi-dimensional table provided by a multi-dimensional phenotypic elite archiving algorithm.

[0181] In some other alternative implementations of this example, a current parent solution selection module includes: The selection weight determination submodule is configured to determine the selection weights of each annular strip constituting a link topology according to a multi-stage improvement strategy; wherein, the magnitude of a selection weight is directly proportional to the probability that a historical solution in its population is used as a historical parent solution to produce an effective solution, and the effective solution produced is directly proportional to the degree to which the corresponding historical parent solution satisfies the requirements of a task. The target selection strip determination submodule is configured to determine the segment strip with the highest selection weight as the target selection strip; The current parent solution selection submodule is configured to select a current parent solution from the historical solutions stored in a target selection strip.

[0182] In some other alternative implementations of this example, a current parent solution selects a child module as follows: The elite solutions stored in a target selection strip are designated as a current parent solution.

[0183] In some other alternative implementations of this example, the magnitude of a selection weight is also proportional to the magnitude of the population entropy, which in turn is proportional to the degree of diversity of historical solutions within the population.

[0184] In some other alternative implementations of this example, an evolutionary solving unit 901 includes an evolutionary experience generation subunit configured to generate evolutionary experience containing evolutionary orientation corresponding to a current evolutionary round, based on a multi-stage improvement strategy and the actual degree to which a current solution meets a task requirement. The evolutionary experience generation subunit is further configured to: The improvement expectation is determined based on a multi-stage improvement strategy, and the actual improvement is determined based on the actual degree to which a current solution meets the requirements of a task. Determine the degree of matching based on the difference between an actual improvement and an expected improvement; Positive and negative contributions are determined based on a matching degree. Based on a positive contribution and a negative contribution, an improvement suggestion is generated for a current solution to maintain at least a positive contribution and to mitigate a negative contribution as much as possible; wherein, an evolutionary experience includes: a matching degree, a positive contribution, a negative contribution and an improvement suggestion.

[0185] In some other alternative implementations of this example, an evolutionary experience generation subunit may also include: The improvement suggestion adjustment module is configured to adjust an improvement suggestion based on an unexpected performance in a current solution that exceeds an expected improvement.

[0186] In some other alternative implementations of this example, the problem processing apparatus 900 based on evolutionary agents further includes: an experience summarization unit configured to summarize different evolutionary experiences generated from different historical solutions at different historical evolutionary stages, wherein the experience summarization unit is further configured to: Identify parent-child historical solutions with parent-child relationships among different historical solutions, and generate a summary of parent-child solution evolutionary experiences based on the differences between different evolutionary experiences corresponding to a parent-child historical solution. Different child historical solutions corresponding to the same parent historical solution are identified in different historical solutions. Based on the differences between the evolutionary experiences corresponding to each child historical solution that is in a parallel relationship, a summary of evolutionary experiences of parallel child solutions is generated. Among them, a summary of historical evolutionary experiences includes: a summary of evolutionary experiences of parent and child solutions and a summary of evolutionary experiences of parallel child solutions.

[0187] This embodiment exists as a device embodiment corresponding to the above method embodiment. The complex problem processing device based on evolutionary intelligent agents provided in this embodiment realizes the automated and evolutionary solution of complex problems through a closed-loop process of "task requirements - historical evolutionary experience summary - multi-stage improvement strategy - multi-stage sub-task generation and execution - evolutionary experience generation and update - iterative solution". First, based on the current task requirements and the evolutionary experience summary of different historical solutions, a multi-stage improvement strategy compared to the previous round is automatically determined, replacing traditional manual intervention and avoiding the lag of subjective judgment. Then, the complex problem is decomposed into multi-stage sub-tasks that can be executed step by step and executed sequentially to obtain the current solution, which improves the structure and controllability of the solution process. If the current solution does not meet the task requirements, experience containing evolutionary orientation is generated based on the multi-stage improvement strategy and the actual degree of satisfaction of the current solution, and the historical evolutionary experience summary is updated to realize the systematic accumulation and reuse of past successful experiences and avoid "starting from scratch" in each round of improvement. Finally, by iteratively executing the above steps, continuous iterative optimization is carried out until the target solution that meets the task requirements is obtained, realizing the dynamic improvement of model performance and effectively dealing with the multi-dimensional requirements of complex tasks. This solution can automatically adapt to changes in task requirements without human intervention. Through the accumulation of historical experience and dynamic optimization, it significantly improves the efficiency, accuracy, and evolutionary iteration efficiency of solving complex problems.

[0188] According to embodiments of this disclosure, this disclosure also provides an electronic device, the electronic device comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to implement the complex problem-solving method based on evolutionary intelligent agents described in any of the above embodiments.

[0189] According to embodiments of this disclosure, this disclosure also provides a readable storage medium storing computer instructions that enable a computer to implement the complex problem-solving method based on evolutionary intelligent agents described in any of the above embodiments when executed.

[0190] According to embodiments of this disclosure, this disclosure also provides a computer program product that, when executed by a processor, can implement the complex problem-solving method based on evolutionary intelligent agents described in any of the above embodiments.

[0191] Figure 10A schematic block diagram of an example electronic device 1000 that can be used to implement embodiments of the present disclosure is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device may also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the present disclosure described and / or claimed herein.

[0192] like Figure 10 As shown, device 1000 includes a computing unit 1001, which can perform various appropriate actions and processes according to a computer program stored in read-only memory (ROM) 1002 or a computer program loaded into random access memory (RAM) 1003 from storage unit 1008. The RAM 1003 may also store various programs and data required for the operation of device 1000. The computing unit 1001, ROM 1002, and RAM 1003 are interconnected via bus 1004. Input / output (I / O) interface 1005 is also connected to bus 1004.

[0193] Multiple components in device 1000 are connected to I / O interface 1005, including: input unit 1006, such as keyboard, mouse, etc.; output unit 1007, such as various types of monitors, speakers, etc.; storage unit 1008, such as disk, optical disk, etc.; and communication unit 1009, such as network card, modem, wireless transceiver, etc. Communication unit 1009 allows device 1000 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

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

[0195] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0196] The program code used to implement the methods of this disclosure may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus, such that when executed by the processor or controller, the program code causes the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0197] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0198] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device for displaying information to the user (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor); and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the computer. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0199] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as a data server), or computing systems that include middleware components (e.g., an application server), or computing systems that include frontend components (e.g., a user computer with a graphical user interface or web browser through which a user can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., a communication network). Examples of communication networks include local area networks (LANs), wide area networks (WANs), and the Internet.

[0200] Computer systems can include clients and servers. Clients and servers are generally located far apart and typically interact through communication networks. The client-server relationship is created by computer programs running on the respective computers and having a client-server relationship with each other. The server can be a cloud server, also known as a cloud computing server or cloud host, which is a hosting product within the cloud computing service system to address the shortcomings of traditional physical hosts and Virtual Private Server (VPS) services, such as high management difficulty and weak business scalability.

[0201] According to the technical solution of this disclosure, an automated and evolutionary solution to complex problems is achieved through a closed-loop process of "task requirements - historical evolutionary experience summary - multi-stage improvement strategy - multi-stage sub-task generation and execution - evolutionary experience generation and update - iterative solution": First, based on the current task requirements and the evolutionary experience summary of different historical solutions, a multi-stage improvement strategy compared to the previous round is automatically determined, replacing traditional manual intervention and avoiding the lag of subjective judgment; then, the complex problem is decomposed into multi-stage sub-tasks that can be executed step by step and executed sequentially to obtain the current solution, improving the structure and controllability of the solution process; if the current solution does not meet the task requirements, experience containing evolutionary direction is generated based on the multi-stage improvement strategy and the actual degree of satisfaction of the current solution, and the historical evolutionary experience summary is updated, realizing the systematic accumulation and reuse of past successful experiences and avoiding "starting from scratch" in each round of improvement; finally, by iteratively executing the above steps, continuous iterative optimization is carried out until the target solution that meets the task requirements is obtained, realizing the dynamic improvement of model performance and effectively coping with the multi-dimensional requirements of complex tasks. This solution can automatically adapt to changes in task requirements without human intervention. Through the accumulation of historical experience and dynamic optimization, it significantly improves the efficiency, accuracy, and evolutionary iteration efficiency of solving complex problems.

[0202] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this disclosure can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution disclosed in this disclosure can be achieved, and this is not limited herein.

[0203] The specific embodiments described above do not constitute a limitation on the scope of protection of this disclosure. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this disclosure should be included within the scope of protection of this disclosure.

Claims

1. A method for handling complex problems based on evolutionary intelligent agents, comprising: Determine the task requirements and current evolutionary stage of the complex problem to be addressed, and then execute the evolutionary solution steps: Based on the task requirements and the summary of historical evolutionary experience, a multi-stage improvement strategy is determined for the current evolutionary round compared to the previous evolutionary round. The summary of historical evolutionary experience is obtained by summarizing the different evolutionary experiences generated from different historical solutions in different historical evolutionary rounds. Based on the aforementioned multi-stage improvement strategy, multi-stage sub-tasks are generated to process the complex problem to be processed, and each stage sub-task is executed sequentially to obtain the current solution. In response to the current solution not meeting the task requirements, based on the multi-stage improvement strategy and the actual degree to which the current solution meets the task requirements, an evolutionary experience with evolutionary orientation is generated corresponding to the current evolutionary round. The historical evolutionary experience summary is updated using the evolutionary experience of the current evolutionary cycle; The next evolutionary round is taken as the new current evolutionary round, and the evolutionary solution steps are repeated until the target solution that meets the task requirements is obtained.

2. The method according to claim 1, wherein, The process of generating multi-stage sub-tasks for processing the complex problem to be addressed based on the multi-stage improvement strategy, and sequentially executing each stage sub-task to obtain the current solution, includes: Based on the aforementioned multi-stage improvement strategy, the current parent solution is selected from the memory evolution library that stores all historical solutions; Based on the current parent solution, the task requirements, and the multi-stage improvement strategy, a multi-stage sub-task is generated to handle the complex problem to be addressed. The subtasks of each stage are executed sequentially according to the stage order, and the task execution result output by the last stage subtask is determined as the current solution.

3. The method according to claim 2, wherein, The multi-stage improvement strategy and the corresponding multi-stage sub-tasks both include the following multiple task processing stages arranged in sequence: Loading data, cross-validation, feature engineering, model training and prediction, ensemble learning, and workflow encapsulation and integration.

4. The method according to claim 3, further comprising: In response to the personalized requirements included in the task requirements of the complex problem to be addressed, temporary stage subtasks are generated for the personalized requirements. Determine the temporary insertion position of the temporary stage subtask among the existing multiple stage subtasks; The temporary stage subtask is inserted into the existing execution sequence of multiple stage subtasks according to the temporary insertion position, so that each stage subtask is executed sequentially according to the arrangement in the execution sequence.

5. The method according to claim 2, further comprising: After each stage subtask is completed, a subtask verification set corresponding to the completed stage subtask is determined; wherein, the subtask verification set is generated based on the stage improvement strategy corresponding to the corresponding stage subtask. The execution status of the corresponding stage subtasks is verified using the subtask verification set, and the next stage subtask is executed only after the verification is successful.

6. The method according to claim 5, further comprising: In response to any of the aforementioned stage subtasks failing verification, the corresponding stage subtask is regenerated based on the feedback of the failed verification until it passes verification or the number of retries exceeds a preset number. Then, an error message is returned and other unexecuted stage subtasks are terminated.

7. The method according to claim 6, further comprising: The content generated during the execution of the evolutionary solution step will be stored as transient memory; In response to the cumulative storage of the instantaneous memory exceeding the preset upper limit of the preceding information, all currently accumulated instantaneous memories and historical intermediate memories are aggregated, and a semantic summary is generated for the aggregation result as a new intermediate memory. Intermediate memories that have been retained more than a preset number of times and / or whose importance exceeds a preset level are transferred to long-term memories; wherein, the instantaneous memories, the intermediate memories, and the long-term memories are associated with the corresponding historical solutions.

8. The method according to claim 2, wherein, The evolutionary memory bank uses a tree diagram to record all historical solutions. The evolutionary memory bank is a memory storage unit in an evolutionary memory system based on a multi-population island parallel model and a multi-dimensional phenotypic elite archiving algorithm. The structure of the multi-population island parallel model is a ring topology, which is obtained by splicing ring strips corresponding to the number of islands. Each ring strip is used to store the historical solutions belonging to the corresponding population stored on the corresponding island. The elite solutions of each population are recorded by the multi-dimensional table provided by the multi-dimensional phenotypic elite archiving algorithm.

9. The method according to claim 8, wherein, The step of selecting the current parent solution from the evolutionary memory storing all historical solutions based on the multi-stage improvement strategy includes: The selection weights of each annular strip constituting the topology of the link are determined according to the multi-stage improvement strategy; wherein, the magnitude of the selection weight is directly proportional to the probability that the historical solution in the population is used as the historical parent solution to produce an effective solution, and the effective solution produced is directly proportional to the degree to which the corresponding historical parent solution satisfies the task requirements. The segment with the highest selection weight is identified as the target selection segment; The current parent solution is selected from the historical solutions stored in the target selection strip.

10. The method according to claim 9, wherein, The step of selecting the current parent solution from the historical solutions stored in the target selection strip includes: The elite solutions stored in the target selection strip are determined as the current parent solutions.

11. The method according to claim 8, wherein, The selection weight is also proportional to the population entropy of the population to which it belongs, and the population entropy is proportional to the degree of diversity of historical solutions within the population.

12. The method according to any one of claims 1-11, wherein, The process of generating evolutionary experience with evolutionary direction corresponding to the current evolutionary round, based on the multi-stage improvement strategy and the actual degree to which the current solution meets the task requirements, includes: The improvement expectation is determined based on the multi-stage improvement strategy, and the actual improvement is determined based on the actual degree to which the current solution meets the task requirements; The degree of matching is determined based on the difference between the actual improvement and the expected improvement. Positive and negative contributions are determined based on the matching degree. Based on the positive and negative contributions, an improvement proposal is generated for the current solution to at least maintain the positive contribution and to mitigate the negative contribution as much as possible; wherein the evolutionary experience includes: the matching degree, the positive contribution, the negative contribution, and the improvement proposal.

13. The method according to claim 12, wherein, The step of generating evolutionary experience with evolutionary direction corresponding to the current evolutionary round, based on the multi-stage improvement strategy and the actual degree to which the current solution meets the task requirements, further includes: In response to unexpected performance in the current solution that exceeds the expected improvement, the improvement recommendations are adjusted based on the unexpected performance.

14. The method of claim 12, further comprising: This summary is based on the different evolutionary experiences generated from different historical solutions at different stages of evolution, and includes: Identify parent-child historical solutions with parent-child relationships among different historical solutions, and generate a summary of parent-child solution evolutionary experiences based on the differences between the different evolutionary experiences corresponding to the parent-child historical solutions. Different child historical solutions corresponding to the same parent historical solution are identified in different historical solutions, and a summary of evolutionary experiences of parallel child solutions is generated based on the differences between the evolutionary experiences corresponding to each child historical solution that is in a parallel relationship; wherein, the historical evolutionary experience summary includes: the parent-child solution evolutionary experience summary and the parallel child solution evolutionary experience summary.

15. A complex problem-solving apparatus based on evolutionary intelligent agents, comprising: The evolutionary solving unit is configured to determine the task requirements and the current evolutionary round of the complex problem to be processed, and to execute the evolutionary solving steps: based on the task requirements and the summary of historical evolutionary experience, determine the multi-stage improvement strategy of the current evolutionary round compared with the previous evolutionary round, wherein the summary of historical evolutionary experience is obtained by summarizing the different evolutionary experiences generated by different historical solutions of different historical evolutionary rounds; Based on the aforementioned multi-stage improvement strategy, multi-stage sub-tasks are generated to process the complex problem to be processed, and each stage sub-task is executed sequentially to obtain the current solution. In response to the current solution not meeting the task requirements, based on the multi-stage improvement strategy and the actual degree to which the current solution meets the task requirements, an evolutionary experience with evolutionary direction corresponding to the current evolutionary round is generated; the historical evolutionary experience summary is updated using the evolutionary experience of the current evolutionary round. The repeat execution unit is configured to take the next evolutionary round as the new current evolutionary round and repeat the evolutionary solution steps until the target solution that meets the task requirements is obtained.

16. An electronic device comprising: At least one processor; as well as A memory communicatively connected to the at least one processor; wherein, The memory stores instructions executable by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform the complex problem-solving method based on evolutionary agents as described in any one of claims 1-14.

17. A non-transitory computer-readable storage medium storing computer instructions for causing the computer to perform the complex problem-solving method based on an evolutionary intelligent agent as described in any one of claims 1-14.

18. A computer program product comprising a computer program that, when executed by a processor, implements the steps of the complex problem-solving method based on an evolutionary agent according to any one of claims 1-14.

Images