An AI development platform control system based on model lifecycle management

Abstract

The application discloses an AI development platform control system based on model life cycle management and relates to the technical field of AI development platform control. The system comprises a division module, a definition module and the like. The division module is used for dividing the life cycle nodes of a target model based on model life cycle management, obtaining a division node set, establishing a node dependency graph and determining the upstream and downstream node relationship in the division node set. The definition module is used for determining node definition data based on the division node set. The application can automatically detect abnormal nodes through real-time feedback threshold value, automatically backtrack to the upstream nodes for retraining through a preset return amount and a return threshold value, realize node reset training effect of the model instead of overall reset training, improve training efficiency, make the backtracking path controllable through the node dependency graph established by the division module and a dynamic dependency injection mechanism, and ensure that the node connection state stored in the graph database only affects the associated nodes during backtracking, thereby avoiding full-process restart.

Description

Technical Field

[0001] This invention relates to the field of AI development platform control technology, specifically to an AI development platform control system based on model lifecycle management. Background Technology

[0002] AI development platform control system is a software framework for managing and coordinating artificial intelligence development environments, tools, and resources. Its main function is to provide a unified interface and management mechanism to help developers efficiently design, test, deploy, and monitor AI models and applications, schedule and allocate computing resources to optimize the training and inference efficiency of AI models, track version changes of different models and algorithms, ensure the traceability of the development process, and define and manage the AI ​​development workflow, including stages such as data preprocessing, model training, verification, and deployment. Through AI development platform control system, it is beneficial to automate processes, unify resource management, standardize the development environment, significantly reduce manual operations, accelerate AI project iteration, and promote cross-team collaboration.

[0003] A version control system and method based on a low-code development platform, disclosed in patent publication number CN118819616A, sets one or more code update strategies for the source code and generates different versions of revised code according to these strategies. When changes occur in the source code, the changes are synchronized to the revised code according to the update strategies. This eliminates the need for developers to manually update each revised code version, reducing their workload and improving the efficiency of managing different versions of code.

[0004] When the above and similar technical solutions are used, the lack of an automated rollback mechanism in the model lifecycle management of conventional methods leads to the reliance on manual intervention for anomaly recovery, which is inefficient and has a high risk of process interruption. Specifically, it manifests as weak node status management, lack of product version control, and insufficient intelligent decision-making capabilities, making it impossible to automatically trace back to upstream nodes for repair. Consequently, when anomalies occur and model retraining is required, it not only wastes computing resources but also prolongs the training time. Summary of the Invention

[0005] The purpose of this invention is to provide an AI development platform control system based on model lifecycle management to solve the problems mentioned in the background art.

[0006] To achieve the above objectives, the present invention provides the following technical solution: an AI development platform control system based on model lifecycle management, comprising:

[0007] Partitioning Module: Based on model lifecycle management, the target model is partitioned into lifecycle nodes to obtain a partitioned node set, and a node dependency graph is established to determine the upstream and downstream node relationships in the partitioned node set;

[0008] Definition module: Based on the partitioned node set, determine the node definition data, including input dependency data, output result data, and execution logic data, to obtain the node reference dataset;

[0009] Training module: The model is trained based on the partitioned node set and the node comparison dataset. A feedback threshold is set, and real-time feedback data of the partitioned node set is obtained to obtain real-time feedback items.

[0010] When there are nodes in the node set where the real-time feedback items have not reached the feedback threshold, the node is identified as an abnormal node. Using the abnormal node as the backtracking point, the target number of nodes are backtracked to obtain the backtracked node items, and the model is retrained.

[0011] Optimization module: Obtain the updated training feedback data of the returned node item again to get the updated feedback item, compare the updated feedback item with the real-time feedback item, and replace the node with the node whose feedback data is larger based on the comparison result;

[0012] Simultaneously, the secondary training result data of abnormal nodes is acquired, and the secondary training result data is judged. If the feedback threshold is still not reached, the process is repeated until the training result data reaches the feedback threshold, and then the model training of the next node is carried out. This realizes node training based on the full life cycle management of the model.

[0013] Furthermore, the method for obtaining the partitioned node set includes:

[0014] Nodes are defined using standardized data, including the number of nodes and node processes, resulting in node information items.

[0015] Based on node information items, obtain node attribute definition data, create a node attribute definition table, and connect node information items through a node connection control mechanism;

[0016] Set up a storage framework to store node information items after docking, and obtain the partitioned node set.

[0017] Furthermore, the method for establishing the node dependency graph includes:

[0018] Define the core architecture design structure, obtain the target model data, and based on the mathematical representation model, obtain the model display structure data: ,in This represents the partitioning of the node set. It represents edge set information, used to indicate the dependencies between partitioned node sets;

[0019] A dependency matrix is ​​established, dynamic dependency injection is performed based on the model's structural data, the connection status of the partitioned node set is obtained through cross-node dependency query, node information items are obtained, and the node information items are stored through graph database design to obtain the node dependency graph.

[0020] Furthermore, the method for obtaining the node reference dataset includes:

[0021] Based on the partitioned node set, define the node element architecture, including the node metadata structure;

[0022] Input dependency management solutions, including dependency resolution engine, dynamic dependency injection API, and dependency breakpoint handling strategies;

[0023] The output results are designed in a standardized manner, including standardized templates for output objects. The relationships between the graph data are obtained through automatic registration and version control, resulting in a node comparison dataset.

[0024] Furthermore, the feedback threshold includes the amount of training data output, and the method for obtaining the real-time feedback item includes:

[0025] Based on the real-time training data of the partitioned node set, the training data output of the current training node is obtained, and the real-time output of the node is obtained.

[0026] A training threshold is set, which is the number of training iterations. Based on the training threshold, the node set is repeatedly trained to obtain the average training data output of the training nodes, thereby obtaining the real-time feedback item.

[0027] Furthermore, the return method includes:

[0028] Set a return amount, which is a fixed number of nodes. Based on the return point, return the number of nodes according to the return amount to obtain at least one returned node.

[0029] Set a return threshold and a return increment. The return threshold is the number of returns, and the return increment is the number of nodes to be returned. Return decisions are made based on the return threshold. When the number of returns reaches the return threshold, the number of nodes is returned based on the combination of the return increment and the return amount.

[0030] Furthermore, the method for obtaining the update feedback item includes:

[0031] Based on the returned node item, reload the checkpoint data that corresponds to the returned node item, including training data, code version data, and training environment data, to obtain the node comparison data item;

[0032] The update feedback term is obtained by updating the back node based on the node comparison data item.

[0033] Furthermore, the method for obtaining the update feedback item also includes:

[0034] Access the manual intervention interface, connect to the rollback node item based on the manual intervention interface, load and update checkpoint data. The updated checkpoint data includes updating training data, updating code version data, and updating training environment data. Obtain the training feedback data of the rollback node item to obtain the updated feedback item.

[0035] Compared with the prior art, the beneficial effects of the present invention are:

[0036] This AI development platform control system, based on model lifecycle management, automatically detects abnormal nodes through real-time feedback thresholds. By setting preset rollback amounts and thresholds, it automatically backtracks to upstream nodes for retraining, achieving node-level retraining rather than overall model retraining, thus improving training efficiency. The node dependency graph established through module division and the dynamic dependency injection mechanism make the rollback path precise and controllable. The node connection status stored in the graph database ensures that rollback only affects related nodes, avoiding a full restart. By eliminating human judgment errors and accelerating problem localization, the development iteration cycle is compressed, significantly improving the platform's robustness.

[0037] Meanwhile, the optimization module automatically loads historical checkpoint data during rollback to avoid redundant calculations and relies on breakpoint handling strategies to ensure data consistency. The training module dynamically determines rollback needs based on the average output threshold, while the optimization module selects the optimal result to replace the updated feedback item by comparing it with the real-time feedback item. This mechanism reduces invalid training and improves the utilization of computing resources such as GPUs. Attached Figure Description

[0038] Figure 1 This is a schematic diagram of the overall process of the present invention;

[0039] Figure 2 This is a schematic diagram of the process for obtaining the partitioned node set according to the present invention;

[0040] Figure 3 This is a schematic diagram showing the relationship between node names and node processes in this invention;

[0041] Figure 4 This is a schematic diagram illustrating the relationship between the direct upstream node and the direct downstream node of the present invention;

[0042] Figure 5 This is a schematic diagram of the return amount structure of the present invention. Detailed Implementation

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

[0044] In the artificial intelligence development platform control system, model life cycle management is a crucial link. However, the lack of an automated rollback mechanism that is prevalent in current conventional methods in this link is increasingly highlighting its negative impacts on development efficiency, resource utilization, and process stability. This lack not only makes anomaly recovery highly dependent on manual intervention, leading to low efficiency and the risk of process interruption, but also causes significant waste in resource utilization and time costs. In the current AI development platform control system, the defects in model life cycle management are mainly reflected in the following aspects. First, the node status management is weak. In each stage of model training, verification, and deployment, there is a lack of real-time monitoring and accurate recording of node status. Once an anomaly occurs in a certain node, it is difficult to quickly locate the root cause of the problem and take effective measures for intervention in a timely manner. This lack of status management makes the entire model life cycle like a "black box", and after an anomaly occurs, it can only rely on manual experience for judgment and processing, with low efficiency and high error proneness. Second, the lack of product version control. During the model training process, a large number of intermediate products and final model files are generated. Without an effective version control mechanism, it is difficult to track the differences between different versions and quickly roll back to a previous stable version. When problems occur in the current version, it is not convenient to roll back to the previous version for debugging and repair, and it is necessary to retrain from scratch, resulting in a huge waste of time and computing resources. And the AI development platform control system based on model life cycle management provided by this application automatically detects abnormal nodes through real-time feedback thresholds, and automatically retraces to upstream nodes for retraining by presetting the rollback amount and rollback threshold, achieving the effect of node reset training for the model rather than overall reset training, improving the training efficiency. Through the node dependency graph established by dividing modules and the dynamic dependency injection mechanism, the rollback path is accurately controllable. The node connection status stored in the graph database ensures that only associated nodes are affected during rollback, avoiding a full process restart. By eliminating manual judgment errors and accelerating problem location, the development iteration cycle is compressed, significantly enhancing the platform robustness. As Figure 1 shown, it includes a division module, a definition module, a training module, and an optimization module.

[0045] Division module: Based on model life cycle management, divide the life cycle nodes of the target model and establish a node dependency graph.

[0046] It is important to note that the target model is divided into lifecycle nodes to obtain a set of partitioned nodes, and a node dependency graph is established to determine the upstream and downstream node relationships in the partitioned node set.

[0047] It is important to note that, such as Figure 2 As shown, the method for obtaining the partitioned node set includes: standardizing node definition data, including the number of nodes and node processes, to obtain node information items; based on the node information items, obtaining node attribute definition data, creating a node attribute definition table, and connecting the node information items through a node connection control mechanism; setting a storage framework, which is used to store the connected node information items, to obtain the partitioned node set.

[0048] Specifically, such as Figure 3 As shown, by defining standardized data through nodes, the number of nodes and node processes are set, with the node processes corresponding to the number of nodes. The number of nodes is set to eight, namely data collection, data validation, feature engineering, model training, model validation, deployment, monitoring, and decommissioning. Simultaneously, node processes corresponding to the number of nodes are defined, namely obtaining raw data, data quality assurance, constructing the feature space, generating the prediction model, performance evaluation, service deployment, online tracking, and resource recycling. This yields node information items, their definition data, and a node attribute definition table, as shown in Table 1.

[0049] Table 1

[0050]

[0051] The node connection control mechanism connects the node information items. The node connection control mechanism includes an admission check design and a storage framework. The storage framework is used to store the node information items after connection, resulting in a partitioned node set.

[0052] It is important to note that the method for establishing a node dependency graph includes: defining the core architecture design structure, obtaining the target model data, and obtaining the model display structure data based on a mathematical representation model. ,in This represents the partitioning of the node set. Edge set information is used to represent the dependencies of the partitioned node set; a dependency matrix is ​​established, dynamic dependency injection is performed based on the model display structure data, the connection status of the partitioned node set is obtained through cross-node dependency query, node information items are obtained, and the node information items are stored through graph database design to obtain the node dependency graph.

[0053] Specifically, such as Figure 4 As shown, since the number of nodes is set to eight, namely data acquisition, data validation, feature engineering, model training, model validation, deployment, monitoring, and decommissioning, the following results were obtained: The structural distribution of nodes is represented by the dependency relationships between nodes, which indicate the hierarchical relationships between nodes. A dependency matrix is ​​established, and the dependency relationships of nodes within a given number of nodes are shown in Table 2.

[0054] Table 2

[0055]

[0056] In cross-node dependency queries, all upstream links of a node are obtained and visualized. Node information items are stored using a graph database design to obtain a node dependency graph.

[0057] Definition Module: Based on the partitioned node set, determine the node definition data, including input dependency data, output result data, and execution logic data.

[0058] It is important to note that after determining the node definition data, a node comparison dataset is obtained. The methods for obtaining the node comparison dataset include: defining the node element architecture based on the partitioned node set, including the node metadata structure; inputting a dependency management scheme, including a dependency parsing engine, a dynamic dependency injection API, and a dependency breakpoint handling strategy; designing the output result specifications, including standardized templates for output items; and obtaining the graph data relationships through automatic registration and version control to obtain the node comparison dataset.

[0059] Specifically, the node metadata structure is as follows:

[0060] {

[0061] "node_name": "Model Training",

[0062] "version": "v2.3",

[0063] "input_dependencies": [

[0064] {

[0065] "name": "Feature Set",

[0066] "type": "parquet",

[0067] "required": true,

[0068] "validation": "md5: a1b2c3d4e5",

[0069] "source_node": "Feature Engineering"

[0070] },

[0071] {

[0072] "name": "Hyperparameter configuration",

[0073] "type": "yaml",

[0074] "required": false,

[0075] "default": "default_hparams.yaml"

[0076] }

[0077] ],

[0078] "output_results": [

[0079] {

[0080] "name": "model file",

[0081] "type": "onnx",

[0082] "storage": "s3: / / models / projectX / v1.onnx",

[0083] "metadata": {

[0084] "metrics": {"auc": 0.92, "latency": 85},

[0085] "framework": "PyTorch 2.1"

[0086] }

[0087] },

[0088] {

[0089] "name": "Training Report",

[0090] "type": "html",

[0091] "storage": "s3: / / reports / train_20250731.html"

[0092] }

[0093] ],

[0094] "execution_logic": {

[0095] "type": "docker",

[0096] "image": "registry.company.ai / ml-train:v2.3",

[0097] "command": "python train.py --input ${INPUT_DIR} --output ${OUTPUT_DIR}",

[0098] "resource": {

[0099] "gpu": "A100x2",

[0100] "memory": "32GiB",

[0101] "timeout": "6h"

[0102] }

[0103] }

[0104] }

[0105] The breakpoint handling strategy is shown in Table 3:

[0106] Table 3

[0107]

[0108] After the output is standardized with a template, it is automatically registered and version controlled. The multi-mode execution engine and execution logic configurator are used to output the comparison data and monitor the execution process. The data is then displayed on the full lifecycle management console.

[0109] Training module: The model is trained based on the partitioned node set and the node comparison dataset. A feedback threshold is set, and nodes that do not reach the feedback threshold are returned and the model is retrained.

[0110] It is important to note that to obtain real-time feedback data from the partitioned node set and thus obtain real-time feedback items, the feedback threshold includes the training data output volume. The method for obtaining real-time feedback items includes: based on the real-time training data of the partitioned node set, obtaining the training data output volume of the current training node to obtain the real-time output volume of the node; setting a training threshold, which is a training count threshold, and repeatedly training the partitioned node set based on the training threshold to obtain the average training data output volume of the training node, thereby obtaining the real-time feedback items.

[0111] Specifically, the training threshold is set to three times. That is, the training node is repeatedly trained based on the training threshold to obtain the training data output of a single training node multiple times, obtain the average training data output of the training node, and then obtain the real-time feedback item.

[0112] It is important to note that when there are nodes in the node set where the real-time feedback items have not reached the feedback threshold, these nodes are identified as abnormal nodes. Using the abnormal node as the return point, the target number of nodes are returned to obtain the returned node items, and the model is retrained.

[0113] It is important to note that the rollback method includes: setting a rollback amount, which is a fixed number of nodes; using the rollback point as a baseline, rolling back the number of nodes based on the rollback amount to obtain at least one rolled-back node; setting a rollback threshold and a rollback increment, where the rollback threshold is a threshold for the number of rollbacks, and the rollback increment is the increment of the number of rolled-back nodes; making rollback decisions based on the rollback threshold; and when the number of rollbacks reaches the rollback threshold, rolling back the number of nodes based on the combination of the rollback increment and the rollback amount.

[0114] Specifically, the return amount is 2, which is two fixed number of nodes. Based on the return point, the number of nodes is returned according to the return amount, resulting in two returned nodes. Let the return point be N, and the two returned nodes are N-1 and N-2. The set return threshold and return increment are 3 and 1 respectively. When the number of returns reaches the return threshold, the number of nodes is returned based on the combination of the return increment and the return amount.

[0115] In the specific implementation process, such as Figure 5 As shown, model training is being performed for a specific AI development project. The model has eight nodes: data acquisition, data validation, feature engineering, model training, model validation, deployment, monitoring, and decommissioning. Data training is performed on each node. When a node is in the model validation phase, if the real-time feedback item for that node does not reach the feedback threshold, "model validation" is set as the backtracking point. Based on the set backtracking amount, two nodes are regressed from "model validation" (i.e., model training and feature engineering), and data training is restarted with feature engineering as the node. The process continues until the set training threshold is reached and feedback is achieved. When the threshold is reached, data training is performed again using model training as the node. When the set training threshold and feedback threshold are reached, data training is performed again using model validation as the node, thus realizing automatic node rollback. If the real-time feedback item corresponding to the node in this stage still does not reach the feedback threshold, the rollback step is repeated. When the rollback step is executed three times in a row, that is, when the set rollback threshold is reached, the rollback is performed three times according to the set rollback increment, that is, back to the data validation node, and data training is performed again until the real-time feedback item corresponding to the node in the stage corresponding to the rollback point still reaches the feedback threshold.

[0116] Optimization module: Obtain the updated training feedback data of the returned node item again, obtain the updated feedback item, and replace it with the training result of the node with the larger feedback data.

[0117] It is important to note that after obtaining the updated feedback item, by comparing the updated feedback item with the real-time feedback item, the training result of the node with the larger feedback data is used as the replacement based on the comparison result. The method for obtaining the updated feedback item includes: based on the returned node item, reloading the checkpoint data that corresponds to the returned node item, including training data, code version data, and training environment data, to obtain the node comparison data item; and performing update training on the returned node based on the node comparison data item to obtain the updated feedback item.

[0118] In the specific implementation process, the existing bank loan default prediction model, during the model validation phase, found that the AUC was 0.81, which is lower than the 0.85 threshold, requiring a rollback. This necessitates reloading the checkpoint data corresponding to the rolled-back node, including training data, code version data, and training environment data. The training data recovery process is as follows:

[0119] # Metadata service query (tracing by lineage ID)

[0120] curl -X GET https: / / metadata.company.ai / v1 / lineage \

[0121] -H "Content-Type: application / json" \

[0122] -d '{

[0123] "node": "model_training",

[0124] "checkpoint_id": "train_20250730_1432"

[0125] }'

[0126] # Example of returned results

[0127] {

[0128] "training_data": {

[0129] "path": "s3: / / ai-platform / project_finance / train_data / v2_20250730.parquet",

[0130] "version": "v2.3",

[0131] "fingerprint": "md5:8d3f7a2c1b45e9d6f0a8c", # Data integrity check code

[0132] "statistics": { # Data quality snapshot

[0133] "row_count": 125000,

[0134] "feature_distribution": {

[0135] "income": {"mean": 85600, "std": 23000},

[0136] "debt_ratio": {"median": 0.35}

[0137] }

[0138] }

[0139] }

[0140] }

[0141] A reconstruction operation is required. The process is as follows:

[0142] # Load data from storage service

[0143] aws s3 cp s3: / / ai-platform / project_finance / train_data / v2_20250730.parquet . / recovery_data /

[0144] # Verify data integrity

[0145] echo "8d3f7a2c1b45e9d6f0a8c" > expected.md5

[0146] md5sum recovery_data / v2_20250730.parquet | diff - expected.md5

[0147] Simultaneously, code version rollback is required, the process of which is as follows:

[0148] # Code repository location (based on training node execution records)

[0149] git reflog show --date=iso 'model_train#20250730'

[0150] # Output key information

[0151] 7a2b3f1 (HEAD -> feature / risk-model-v2) HEAD@{2025-07-30 14:32:22 +0800}:

[0152] commit: Fix gradient explosion in RNN layers

[0153] Diff Summary:

[0154] src / model_train.py | 12 +++++++++---

[0155] config / hparams.yaml | 4 ++--

[0156] A reconstruction operation is also required, and the process is as follows:

[0157] # Revert to the specified submission

[0158] git checkout 7a2b3f1 -b recovery_branch

[0159] # Verify key code differences

[0160] git diff HEAD~1 -- src / model_train.py

[0161] > + optimizer.step(cap_grad_norm=1.0) # Add gradient clipping

[0162] Finally, the training environment needs to be restored, and the process is as follows:

[0163] # Rebuild Docker image file (Dockerfile.checkpoint)

[0164] FROM registry.company.ai / pytorch:1.12.1-cuda11.6

[0165] # Fixed underlying dependencies

[0166] RUN pip freeze > requirements.txt && \

[0167] cat requirements.txt

[0168] torch==1.12.1+cu116

[0169] scikit-learn==1.2.2

[0170] pandas==1.5.3 # Specify the exact version

[0171] # Environment snapshot metadata

[0172] ENV CHECKPOINT_ID="train_20250730_1432"

[0173] ENV GPU_CONF="CUDA_VISIBLE_DEVICES=0,1"

[0174] Finally, perform the reconstruction operation:

[0175] # Building a deterministic environment

[0176] docker build -t recovery_train_env -f Dockerfile.checkpoint .

[0177] # Start the training container

[0178] docker run -it \

[0179] -v . / recovery_data: / data \

[0180] -e CHECKPOINT_ID=$CHECKPOINT_ID \

[0181] recovery_train_env \

[0182] python src / model_train.py --data_version v2.3

[0183] Finally, we obtain the training data, code version data, and training environment data that correspond to the returned node items, obtain the node comparison data items, perform updated training, and obtain the updated training feedback items.

[0184] It should be noted that the method for obtaining the update feedback item also includes: accessing the manual intervention interface, connecting with the rollback node item based on the manual intervention interface, loading the update checkpoint data, which includes updating the training data, updating the code version data, and updating the training environment data, obtaining the training feedback data of the rollback node item, and obtaining the update feedback item.

[0185] Specifically, through the manual intervention interface, the training data, code version data, and training environment data can be adjusted to obtain updated training data, updated code version data, and updated training environment data. Training can then be performed based on the updated data, allowing for further modifications to the training results based on the original training.

[0186] It is important to note that the secondary training results of abnormal nodes are also acquired and evaluated. If the feedback threshold is still not reached, the process is repeated until the training results reach the feedback threshold and the model training for the next node is performed. This achieves node training based on the full lifecycle management of the model.

[0187] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended embodiments and their equivalents.

Claims

1. A control system for an AI development platform based on model lifecycle management, comprising: Partitioning Module: Based on model lifecycle management, the target model is partitioned into lifecycle nodes to obtain a partitioned node set, and a node dependency graph is established to determine the upstream and downstream node relationships in the partitioned node set; Its features are: Definition module: Based on the partitioned node set, determine the node definition data, including input dependency data, output result data, and execution logic data, to obtain the node reference dataset; Training module: The model is trained based on the partitioned node set and the node comparison dataset. A feedback threshold is set, and real-time feedback data of the partitioned node set is obtained to obtain real-time feedback items. When there are nodes in the node set where the real-time feedback items have not reached the feedback threshold, the node is identified as an abnormal node. Using the abnormal node as the backtracking point, the target number of nodes are backtracked to obtain the backtracked node items, and the model is retrained. Optimization module: Obtain the updated training feedback data of the returned node item again to get the updated feedback item, compare the updated feedback item with the real-time feedback item, and replace the node with the node whose feedback data is larger based on the comparison result; Simultaneously, the secondary training result data of abnormal nodes is obtained, and the secondary training result data is judged. If the feedback threshold is still not reached, the process is repeated until the training result data reaches the feedback threshold and the model training of the next node is carried out, thereby realizing node training based on the full life cycle management of the model. The method for obtaining the node reference dataset includes: Based on the partitioned node set, define the node element architecture, including the node metadata structure; Input dependency management solutions, including dependency resolution engine, dynamic dependency injection API, and dependency breakpoint handling strategies; The output results are designed in a standardized manner, including standardized templates for output objects. The relationships between the graph data are obtained through automatic registration and version control, resulting in a node comparison dataset.

2. The AI ​​development platform control system based on model lifecycle management according to claim 1, characterized in that: The method for obtaining the partitioned node set includes: Nodes are defined using standardized data, including the number of nodes and node processes, resulting in node information items. Based on node information items, obtain node attribute definition data, create a node attribute definition table, and connect node information items through a node connection control mechanism; Set up a storage framework to store node information items after docking, and obtain the partitioned node set.

3. The AI ​​development platform control system based on model lifecycle management according to claim 1, characterized in that: The method for establishing the node dependency graph includes: Define the core architecture design structure, obtain the target model data, and based on the mathematical representation model, obtain the model display structure data: ,in This represents the partitioning of the node set. It represents edge set information, used to indicate the dependencies between partitioned node sets; A dependency matrix is ​​established, dynamic dependency injection is performed based on the model's structural data, the connection status of the partitioned node set is obtained through cross-node dependency query, node information items are obtained, and the node information items are stored through graph database design to obtain the node dependency graph.

4. The AI ​​development platform control system based on model lifecycle management according to claim 1, characterized in that: The feedback threshold includes the amount of training data output, and the method for obtaining the real-time feedback item includes: Based on the real-time training data of the partitioned node set, the training data output of the current training node is obtained, and the real-time output of the node is obtained. A training threshold is set, which is the number of training iterations. Based on the training threshold, the node set is repeatedly trained to obtain the average training data output of the training nodes, thereby obtaining the real-time feedback item.

5. The AI ​​development platform control system based on model lifecycle management according to claim 1, characterized in that: The return method includes: Set a return amount, which is a fixed number of nodes. Based on the return point, return the number of nodes according to the return amount to obtain at least one returned node. Set a return threshold and a return increment. The return threshold is the number of returns, and the return increment is the number of nodes to be returned. Return decisions are made based on the return threshold. When the number of returns reaches the return threshold, the number of nodes is returned based on the combination of the return increment and the return amount.

6. The AI ​​development platform control system based on model lifecycle management according to claim 1, characterized in that: The methods for obtaining the update feedback items include: Based on the returned node item, reload the checkpoint data that corresponds to the returned node item, including training data, code version data, and training environment data, to obtain the node comparison data item; The update feedback term is obtained by updating the back node based on the node comparison data item.

7. The AI ​​development platform control system based on model lifecycle management according to claim 6, characterized in that: The method for obtaining the update feedback item also includes: Access the manual intervention interface, connect to the rollback node item based on the manual intervention interface, load and update checkpoint data. The updated checkpoint data includes updating training data, updating code version data, and updating training environment data. Obtain the training feedback data of the rollback node item to obtain the updated feedback item.

Images