AI development platform control system based on model life cycle management

Abstract

The invention discloses an AI development platform control system based on model life cycle management, and relates to the technical field of AI development platform control. Comprising a division module which is used for carrying out life cycle node division on a target model based on model life cycle management to obtain a division node set, establishing a node dependency graph and determining an upstream and downstream node relationship in the division node set; and the definition module is used for determining node definition data based on the divided node set. The abnormal nodes are automatically detected by feeding back the threshold value in real time, and by presetting the return amount and the return threshold value, the node is automatically traced back to the upstream node for retraining, so that the node reset training effect of the model instead of the overall reset training is realized, and the training efficiency is improved; through a node dependency graph and a dynamic dependency injection mechanism established by a division module, a rollback path is accurate and controllable, a node connection state stored in a graph database ensures that only associated nodes are influenced during rollback, and restart of a whole process is avoided.

Description

TECHNICAL FIELD

[0001] The application relates to the technical field of AI development platform control, and particularly relates to an AI development platform control system based on model life cycle management. BACKGROUND

[0002] The 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 AI model training and inference efficiency, track version changes of different models and algorithms, ensure traceability of the development process, define and manage AI development workflows, including data preprocessing, model training, validation and deployment stages, and facilitate automated processes, unified resource management, standardized development environments, significantly reduce manual operations, accelerate AI project iteration and promote cross-team collaboration.

[0003] The patent with the publication number CN118819616A discloses a version control system and method based on a low-code development platform. One or more code update strategies are set for source code, and different versions of revised code are generated according to the code update strategies. In the case of changes in the content of the source code, the content of the source code is synchronized to the revised code according to the code update strategy. In this way, in the case of changes in the content of the source code, developers do not need to update the content of each revised code, reducing the workload of developers and improving the management efficiency of the content of different versions of code.

[0004] The above-mentioned and similar technical solutions have the following problems in use. In the model life cycle management, the conventional method lacks an automatic rollback mechanism, resulting in low efficiency of abnormal recovery depending on manual intervention and high risk of process interruption. Specifically, the node state management is weak, the product version control is missing, and the intelligent decision-making capability is insufficient, which cannot automatically backtrack to the upstream node for repair, thereby causing the training time to be prolonged and the computing resources to be wasted when the model needs to be retrained due to an abnormality. SUMMARY

[0005] The application aims to provide an AI development platform control system based on model life cycle management to solve the problems in the background art.

[0006] To achieve the above-mentioned purpose, the application provides the following technical solution: an AI development platform control system based on model life cycle management, comprising:

[0007] The dividing module: based on the model life cycle management, the target model is divided into life cycle nodes to obtain a set of divided nodes, and a node dependency graph is established to determine the upstream and downstream node relationship in the set of divided nodes;

[0008] The defining module: based on the set of divided nodes, node definition data is determined, including input dependency data, output result data and execution logic data, to obtain a node reference data set;

[0009] The training module: based on the set of divided nodes and the node reference data set, model training is performed, a feedback threshold is set, real-time feedback data of the set of divided nodes is obtained, and real-time feedback items are obtained;

[0010] When there is a node in the set of divided nodes that does not reach the feedback threshold, the node is determined as an abnormal node, and the target number of nodes is returned as a return point to obtain a return node item, and the model training is performed again;

[0011] The optimization module: the updated training feedback data of the return node item is obtained again to obtain updated feedback items, the updated feedback items and the real-time feedback items are compared, and the node training result with greater feedback data is used as the replacement according to the comparison result;

[0012] At the same time, the secondary training result data of the abnormal node is obtained, and the secondary training result data is determined. When the feedback threshold is still not reached, the return is repeated until the training result data reaches the feedback threshold, and the model training of the next node is performed, thereby realizing the node training based on the whole life cycle management of the model.

[0013] Further, the method for obtaining the set of divided nodes comprises:

[0014] The node definition standardization data includes the number of nodes and the node flow to obtain node information items;

[0015] Based on the node information items, node attribute definition data is obtained, a node attribute definition table is created, and the node information items are connected through a node connection control mechanism;

[0016] A storage framework is set to store the connected node information items to obtain the set of divided nodes.

[0017] Further, the method for establishing the node dependency graph comprises:

[0018] A core architecture design structure is set to obtain target model data, and model display structure data is obtained based on a mathematical representation model: , wherein represents the set of divided nodes, represents edge set information for representing the dependency relationship of the set of divided nodes;

[0019] The dependency relationship matrix is established, dynamic dependency injection is performed based on the model display structure data, the connection state of the divided node set is obtained through cross-node dependency query, node information items are obtained, the node information items are stored through graph database design, and a node dependency graph is obtained.

[0020] Further, the node comparison data set acquisition method comprises:

[0021] Based on the divided node set, a node element architecture is defined, including a node metadata structure.

[0022] An input dependency management scheme is input, including a dependency analysis engine, a dynamic dependency injection API, and a dependency breakpoint processing strategy.

[0023] An output result specification design is output, including an output standardization template, graph data relationships are obtained through automatic registration and version control, and a node comparison data set is obtained.

[0024] Further, the feedback threshold comprises training data output, and the real-time feedback item acquisition method comprises:

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

[0026] A training threshold is set, the training threshold is a training frequency threshold, the divided node set is repeatedly trained based on the training threshold, the average training data output of the training node is obtained, and then the real-time feedback item is obtained.

[0027] Further, the return method comprises:

[0028] A return amount is set, the return amount is a fixed number of nodes, and based on the return point, the number of nodes is returned based on the return amount, and at least one returned node is obtained.

[0029] A return threshold and a return increment are set, the return threshold is a return frequency threshold, the return increment is an increment of the number of returned nodes, the return is determined based on the return threshold, and when the return frequency reaches the return threshold, the number of nodes is returned based on the combination result of the return increment and the return amount.

[0030] Further, the update feedback item acquisition method comprises:

[0031] Based on the returned node item, checkpoint data compared with the returned node item is reloaded, including training data, code version data, and training environment data, and a node comparison data item is obtained.

[0032] The returned node is updated based on the node comparison data item, and an update feedback item is obtained.

[0033] Further, the method for obtaining the update feedback item further comprises:

[0034] accessing a manual intervention interface, connecting with the returned node item based on the manual intervention interface, loading update checkpoint data, the update checkpoint data comprising update training data, update code version data and update training environment data, obtaining training feedback data of the returned node item, and obtaining the update feedback item.

[0035] Compared with the prior art, the present application has the beneficial effects that:

[0036] The AI development platform control system based on model life cycle management automatically detects abnormal nodes through real-time feedback thresholds, and automatically traces back to upstream nodes for retraining through preset return amounts and return thresholds, achieving node reset training of the model instead of overall reset training, improving training efficiency, and making the backtracking path controllable through the node dependency graph established by dividing modules and the dynamic dependency injection mechanism, and the node connection state stored in the graph database ensures that only associated nodes are affected during backtracking, avoiding full-process restart, and through eliminating manual judgment errors and accelerating problem positioning, the development iteration cycle is compressed, and the platform robustness is significantly improved.

[0037] Meanwhile, the optimization module automatically loads historical checkpoint data during backtracking, avoids redundant calculation, ensures data consistency through breakpoint processing strategies, and the training module dynamically determines the backtracking demand based on the average output amount threshold, and the optimization module selects the optimal result for replacement by comparing the update feedback item and the real-time feedback item, which reduces invalid training and improves the utilization rate of computing resources such as GPUs. BRIEF DESCRIPTION OF DRAWINGS

[0038] Figure 1 It is a schematic diagram of the overall process of the present application;

[0039] Figure 2 It is a schematic diagram of the process of obtaining the divided node set of the present application;

[0040] Figure 3 It is a schematic diagram of the relationship between the node name and the node process of the present application;

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

[0042] Figure 5 It is a schematic diagram of the return amount structure of the present application. DETAILED DESCRIPTION

[0043] With reference to the accompanying drawings: the technical solutions in the embodiments of the present application will be described clearly and completely, obviously, the described embodiments are only part of the embodiments of the present application, rather than all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative labor belong to the scope of protection of the present application.

[0044] In the artificial intelligence development platform control system, model life cycle management is a crucial link, however, the current conventional method generally lacks automatic rollback mechanism in this link, which is increasingly highlighting its negative impact on development efficiency, resource utilization and process stability, this lack not only makes abnormal recovery highly dependent on manual intervention, leading to low efficiency and process interruption risk, but also causes significant waste in resource utilization and time cost, the defects of model life cycle management in the current AI development platform control system mainly reflect in the following aspects, first, the node state management is weak, in the model training, verification, deployment and other stages, there is a lack of real-time monitoring and accurate recording of node state, once an abnormal node occurs, it is difficult to quickly locate the problem source, and it is impossible to take effective measures for intervention, this lack of state management makes the whole model life cycle like a "black box", after the abnormality occurs, it can only rely on manual experience for judgment and processing, which is low in efficiency and prone to errors, secondly, the product version control is missing, in the model training process, a large number of intermediate products and final model files will be generated, if there is no effective version control mechanism, it is difficult to track the differences between different versions, and it is also difficult to quickly backtrack to the previous stable version, when the current version has a problem, it is not convenient to roll back to the previous version for debugging and repair, and it has to be retrained, causing a huge waste of time and computing resources, while the AI development platform control system based on model life cycle management provided by the present application detects abnormal nodes through real-time feedback threshold, and automatically retraces to the upstream node for retraining through the preset rollback amount and rollback threshold, realizing the node reset training effect of the model instead of the overall reset training, improving the training efficiency, through the division module to establish the node dependency graph and the dynamic dependency injection mechanism, the rollback path is accurately controllable, the node connection state stored in the graph database ensures that only the associated nodes are affected during rollback, avoiding full process restart, through eliminating manual judgment errors and accelerating problem positioning, the development iteration cycle is compressed, and the platform robustness is significantly improved, as Figure 1 As 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, the target model is divided into life cycle nodes to establish a node dependency graph.

[0046] It should be noted that the target model is divided into a lifecycle node set, and a node dependency graph is established to determine the upstream and downstream node relationship in the divided node set.

[0047] It should be noted that, as Figure 2 indicated, the method for obtaining the divided node set includes: defining standardized data of nodes, including the number of nodes and the node process, 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, and the storage framework is used to store the connected node information items to obtain the divided node set.

[0048] Specifically, as Figure 3 indicated, the number of nodes and the node process are set through the node definition standardized data, the node process corresponds to the number of nodes, the number of nodes is set to eight, which are data collection, data verification, feature engineering, model training, model verification, deployment, monitoring and retirement, and the node process corresponding to the number of nodes is also set, which are obtaining original data, data quality assurance, constructing feature space, generating prediction model, performance evaluation, online service, online tracking and resource recycling, to obtain node information items, and the definition data of the node information items is obtained, and a node attribute definition table is created, as shown in Table 1:

[0049] Table 1

[0050]

[0051] The node information items are connected through the node connection control mechanism, which includes admission check design, setting a storage framework, and the storage framework is used to store the connected node information items to obtain the divided node set.

[0052] It should be noted that the method for establishing the node dependency graph includes: setting a core architecture design structure to obtain target model data, and based on a mathematical representation model, obtaining model display structure data: , wherein represents the divided node set, represents edge set information, which is used to represent the dependency relationship of the divided node set; a dependency relationship matrix is established, dynamic dependency injection is performed based on the model display structure data, the connection state of the divided node set is obtained through cross-node dependency query, the node information items are stored through graph database design, and the node dependency graph is obtained.

[0053] Specifically, as Figure 4 indicated, since the number of nodes is set to eight, which are data collection, data verification, feature engineering, model training, model verification, deployment, monitoring and retirement, the 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": "hyperparameters 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 dependency breakpoint handling strategy is shown in Table 3:

[0106] Table 3

[0107]

[0108] The output standardization template is automatically registered and version controlled, and the output data is compared through a multi-mode execution engine and an execution logic configurator. The execution process is monitored, and the data is reflected in the full life cycle management console.

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

[0110] It should be noted that the real-time feedback data of the division node set is obtained, the real-time feedback item is obtained, the feedback threshold includes the training data output, and the method for obtaining the real-time feedback item includes: based on the real-time training data of the division node set, the training data output of the current training node is obtained, the node real-time output is obtained; set the training threshold, the training threshold is the training times threshold, based on the training threshold, the division node set is repeatedly trained, the average training data output of the training node is obtained, and then the real-time feedback item is obtained.

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

[0112] It should be noted that when there are nodes in the division node set that do not reach the feedback threshold, the node is determined to be an abnormal node, and the target number of nodes is returned to the return point, the return node item is obtained, and the model training is re-performed.

[0113] It should be noted that the return method includes: setting a return amount, the return amount is a fixed number of nodes, based on the return point, the return amount is used to return the number of nodes, and at least one return node is obtained; set the return threshold and the return increment, the return threshold is the return threshold, and the return increment is the return node number increment, based on the return threshold, the return is determined, when the return times reach the return threshold, the return amount is combined with the return increment to return the number of nodes.

[0114] Specifically, the return amount is 2, that is, two fixed node numbers, based on the return point, the return amount is used to return the number of nodes, and two return nodes are obtained, the return point is N, and the two return nodes are N-1 and N-2, the return threshold and the return increment are set to 3 and 1 respectively, when the return times reach the return threshold, the return amount is combined with the return increment to return the number of nodes.

[0115] In the specific implementation process, as shown in Figure 5 The model training is performed for a certain AI development, the number of nodes of the model is set to eight, which are data collection, data verification, feature engineering, model training, model verification, deployment, monitoring and retirement, and the nodes of the model are trained, when the node is in the model verification stage, the real-time feedback item corresponding to the node in the stage does not reach the feedback threshold, at this time, the "model verification" is set as the return point, and the "model verification" is set as the return point, and the "model verification" is set as the return point. According to the set return amount, two nodes, model training and feature engineering, are returned, and data training is performed again with feature engineering as the node, when the set training threshold is reached and the feedback threshold is reached, data training is performed again with model training as the node, and data training is performed again with model training as the node. When the set training threshold is reached and the feedback threshold is reached, data training is performed again with model training as the node, and data training is performed again with model training as the node. When the real-time feedback item corresponding to the node in the stage still does not reach the feedback threshold, the return step is repeated again, when the return step is executed for three times, that is, the set return threshold is reached, according to the set return increment, three nodes are returned, that is, the data verification node is returned, and data training is performed again, until the real-time feedback item corresponding to the node in the stage as the return point reaches the feedback threshold.

[0116] Optimization module: Obtain the updated training feedback data of the rollback node item again, get the updated feedback item, and replace the node training result with more feedback data.

[0117] It should be noted that after obtaining the updated feedback item, by comparing the updated feedback item and the real-time feedback item, according to the comparison result, the node training result with more feedback data is replaced as the replacement, and the method for obtaining the updated feedback item includes: based on the rollback node item, reload the checkpoint data compared with the rollback node item, including training data, code version data and training environment data, to obtain the node comparison data item; based on the node comparison data item, the rollback node is updated and trained to obtain the updated feedback item.

[0118] In the specific implementation process, the existing bank loan default prediction model, the model verification stage finds that AUC=0.81, which is lower than the threshold of 0.85, and needs to be rolled back. At this time, the checkpoint data compared with the rollback node item needs to be reloaded, including training data, code version data and training environment data, wherein the training data recovery process is:

[0119] # Metadata service query (trace through blood relationship 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] # Return result example

[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] Reconstruction operation is required, process is:

[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] Code version rollback is also required, process is:

[0148] # Code repository positioning (based on training node execution record)

[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] Similarly, the reconstruction operation is also required, the process is as follows:

[0157] # Roll back to the specified commit

[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) # New gradient clipping

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

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

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

[0165] # Fix 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, the training data, the code version data and the training environment data can be adjusted through the artificial intervention interface, and then updated training data, updated code version data and updated training environment data are obtained. Training is performed based on the updated data, and the training result can be further changed on the basis of the original training.

[0186] It should be noted that the secondary training result data of the abnormal node is obtained at the same time, the secondary training result data is judged, when the feedback threshold is still not reached, the returning is repeated until the training result data reaches the feedback threshold, and the model training of the next node is performed, so that the node training based on the model full life cycle management is realized.

[0187] Although the embodiments of the present application have been shown and described, it can be understood by those skilled in the art that various changes, modifications, replacements and variations can be made to the embodiments without departing from the principles and spirits of the present application, and the scope of the present application is defined by the appended embodiments and their equivalents.

Claims

1. An AI development platform control system based on model lifecycle management, comprising: a division module: based on model lifecycle management, performing lifecycle node division on a target model to obtain a division node set, and establishing a node dependency graph to determine upstream and downstream node relationships in the division node set; characterized in that: a definition module: based on the division node set, determining node definition data including input dependency data, output result data, and execution logic data to obtain a node reference data set; a training module: based on the division node set and the node reference data set, performing model training, setting a feedback threshold, obtaining real-time feedback data of the division node set to obtain real-time feedback items; when there is a node in the division node set that does not reach the feedback threshold, determining the node as an abnormal node, and using the abnormal node as a return point to return a target number of nodes to obtain returned node items and re-perform model training; an optimization module: obtaining updated training feedback data of the returned node items to obtain updated feedback items, comparing the updated feedback items with the real-time feedback items, and according to the comparison result, using the training result of the node with greater feedback data as a replacement; at the same time, obtaining secondary training result data of the abnormal node, determining the secondary training result data, repeating the returning when the training result data still does not reach the feedback threshold, until the training result data reaches the feedback threshold, and performing model training on the next node, thereby realizing node training based on model full lifecycle management.

2. The AI development platform control system based on model lifecycle management according to claim 1, characterized in that: The method for obtaining the division node set comprises: node definition standardized data including node quantity and node flow 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 to store the connected node information items to obtain the division 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 comprises: Set the core architecture design structure, get the target model data, based on the mathematical representation model, get the model display structure data: , wherein represents a set of division nodes, represents edge set information for representing the dependency relationship of the set of division nodes; establishing a dependency relationship matrix, performing dynamic dependency injection based on model display structure data, obtaining connection states of the division node set through cross-node dependency query to obtain node information items, storing the node information items through a 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, wherein: The method for obtaining the node reference data set comprises: based on the division node set, defining a node element architecture including node metadata structure; input dependency management scheme including dependency parsing engine, dynamic dependency injection API, and dependency breakpoint processing strategy; output result specification design including output standardization template, obtaining graph data relationship through automatic registration and version control to obtain the node reference data set.

5. The AI development platform control system based on model lifecycle management according to claim 1, characterized in that: The feedback threshold includes training data output quantity, and the method for obtaining the real-time feedback items comprises: based on real-time training data of the division node set, obtaining training data output quantity of a current training node to obtain node real-time output quantity; setting a training threshold, which is a training frequency threshold, repeatedly training the division node set based on the training threshold to obtain average training data output quantity of the training node, and further obtaining the real-time feedback items.

6. The AI development platform control system based on model lifecycle management according to claim 1, wherein: The return method comprises: The set back amount is a fixed node number, and the node number is backed up based on the set back amount to obtain at least one set back node; The set back threshold and the set back increment are set, the set back threshold is a set back number threshold, the set back increment is a set back node number increment, a set back determination is made based on the set back threshold, when the set back number reaches the set back threshold, the node number is backed up based on the combination result of the set back increment and the set back amount.

7. The AI development platform control system based on model lifecycle management according to claim 1, characterized in that: The method for obtaining the update feedback item comprises: Based on the set back node item, the checkpoint data corresponding to the set back node item is reloaded, including training data, code version data and training environment data, to obtain node comparison data items; Based on the node comparison data items, the set back node is updated and trained to obtain the update feedback item.

8. The AI development platform control system based on model lifecycle management according to claim 7, characterized in that: The method for obtaining the update feedback item further comprises: Accessing an artificial intervention interface, connecting the artificial intervention interface with the set back node item, loading the update checkpoint data, the update checkpoint data including update training data, update code version data and update training environment data, obtaining the training feedback data of the set back node item, and obtaining the update feedback item.

Images