Zero-code end-to-end artificial intelligence model development system based on user intention

Abstract

The invention belongs to the technical field of artificial intelligence, and particularly relates to a zero-code end-to-end artificial intelligence model development system based on user intention, which is suitable for machine learning model development, automatic modeling and industrial-grade AI application deployment scenes. When a user constructs an application model by means of the system, intention analysis and complementation are performed on development requirements input by the user in a multi-modal mode; dynamically constructing an operator combination, and automatically generating a standard workflow suitable for an artificial intelligence task; constructing a workflow for visual editing; a manual intervention adjustment workflow is provided through a visual interface; performing hierarchical test verification on the generated computational graph model; and carrying out automatic iterative optimization on the model. The method is provided with an intention completion mechanism, and accurate mapping of requirements, models and performance is guaranteed; the dynamic operator matching engine can generate a model combination scheme based on a user intention; operators are automatically combined and arranged, and multi-level adjustment from microcosmic parameters to macroscopic topology is supported; and the system is evaluated in a closed loop mode, and full-link optimization is achieved.

Description

Technical Field

[0001] The present invention belongs to the field of artificial intelligence technology, and specifically relates to a zero-code end-to-end artificial intelligence model development system suitable for machine learning model development, automated modeling, and industrial-grade AI application deployment scenarios. Background Art

[0002] Existing zero-code, end-to-end AI model development systems mostly rely on process orchestration and a visual drag-and-drop approach to visualize and build AI development processes. These systems suffer from high parameter coupling between nodes, lack fine-grained debugging capabilities, and most current systems support a single model. With the development of large models and deep learning-based user intent recognition methods, the model operator libraries of zero-code, end-to-end AI model development systems are becoming increasingly rich, but operator matching based on dynamic intent decomposition has not yet been implemented.

[0003] An overview of existing zero-code end-to-end AI model development systems reveals the following shortcomings: First, the semantic gap between user needs and technical implementation leads to deviations in model construction; second, fixed workflow templates are difficult to adapt to dynamic demand changes, and reconfiguration costs are high; third, node-level testing is separated from end-to-end evaluation, making it difficult to locate performance bottlenecks; fourth, traditional visualization systems only support surface parameter adjustments and are unable to deeply optimize operator topology and data flow, resulting in inefficient model iteration and excessive resource consumption.

[0004] In order to further lower the threshold for AI development, there is an urgent need to provide a better zero-code end-to-end AI model development system. Summary of the Invention

[0005] The technical problem to be solved by the present invention is to propose a zero-code end-to-end artificial intelligence model development system based on user intent, which overcomes the defects of insufficient demand analysis, rigid workflow configuration and low iteration efficiency in the existing technology.

[0006] To solve the above technical problems, the present invention proposes a zero-code end-to-end artificial intelligence model development system based on user intent. The method for developing the system to build an application model for the user includes the following steps: Perform intent analysis and completion based on the intelligent system development requirements input by users; Based on AI intent requirements and typical AI models, dynamically build operator combinations and automatically generate standard workflows suitable for AI tasks; Rendering and visualizing the standard workflow to construct a visual editing workflow; Through a visual interface, manual intervention is provided to adjust the workflow, and the model topology and workflow are optimized through data flow verification; Perform hierarchical testing and verification on the generated computational graph model; Based on the results of the inference experiment, the model is automatically iteratively optimized.

[0007] Furthermore, the method for performing intent analysis and completion based on the intelligent system development requirements input by the user includes: Parsing user interaction multimodal input through multimodal intent, Identify key demand nodes in user input intention monitoring, Perform semantic intent completion and conflict detection based on domain knowledge related to the intelligent system to generate formatted intent; Convert formatting intent into the structured intent requirements required by the application model.

[0008] Furthermore, the manual intervention adjustment includes adjusting the topology structure, configuring node hyperparameters and optimizing data flow.

[0009] Furthermore, the manual intervention to adjust the workflow and verify the optimization of the model topology and workflow through data flow includes the following steps: Node-level hyperparameter adjustment is performed through drag-and-drop and parameter setting. Advanced users are supported to input parameter associations through the formula editor. The system verifies the legitimacy of parameters in real time and renders the impact prediction curve. Use the drag-and-drop component library to replace workflow substructure modules; When users modify the model topology, the system calculates the data dependency graph in real time to assess the impact of the adjustment.

[0010] Furthermore, the layered testing and verification of the generated computational graph model includes: Build a sandbox environment based on containers, create isolated test copies, and define environment images; Prioritize test path nodes by path criticality and automatically generate edge cases; Based on the test verification results, a multi-dimensional evaluation is conducted to calculate its comprehensive performance indicators.

[0011] Furthermore, the automatic iterative optimization of the model includes the steps of: Use differential evolution algorithm to optimize node parameters; Build a data validation set for feedback-driven updates; When the model accuracy decreases, the automatic rollback mechanism is triggered and the model is automatically restored to the historical optimal version.

[0012] Furthermore, after automatically iteratively optimizing the model, the development system performs end-to-end optimization on the generated model.

[0013] Optimally, the generated model is optimized end-to-end, comprising the steps of: Eliminate redundant computing nodes through process compression technology; Deploy parallel pipelines, split traffic into different models, and perform stress testing and comparison; Generate evaluation reports, API interface documents and SDK toolkits.

[0014] The beneficial effects of the present invention include: 1) A two-way intent completion mechanism was established to ensure accurate mapping of requirements, models, and performance; 2) Provides a dynamic operator matching engine to generate interpretable model combination solutions based on the intent vector space; 3) It pioneered the automated combination and orchestration of operators, supporting multi-level adjustments from micro-parameters to macro-topology; 4) It has a closed-loop evaluation system that integrates node-level A / B testing and a global performance simulator to achieve full-link optimization. DETAILED DESCRIPTION

[0015] In general, the present invention proposes a zero-code end-to-end artificial intelligence model development system based on user intent. When users use this system to build application models, the system first extracts the explicit / implicit goals in user needs through the multimodal intent parsing module, and generates complete modeling requirements through the knowledge graph-assisted completion algorithm; then, based on the decomposed technical indicators, matching components are dynamically extracted from the operator library and the initial workflow is generated; secondly, the visual editor provides topology adjustment, node hyperparameter configuration and data flow optimization functions; thirdly, a sandbox environment is used to perform node-by-node testing and collect feedback data, and the differential evolution algorithm is used to iteratively update the local model; finally, redundant computing nodes are eliminated through process compression technology, and the shadow deployment mode is combined to complete the end-to-end evaluation.

[0016] To more clearly illustrate the technical solution of the present invention, the specific implementation methods of the present invention are further described in detail below: Step 1: Perform intent analysis and completion based on the user's input for intelligent system development requirements. User input requirements include but are not limited to text, voice, and diagrams. The specific sub-steps are as follows: Step 1-1: Support interactive multimodal input of text, voice, and diagrams through a user interactive multimodal input interface, and use a gated fusion mechanism to achieve cross-modal feature alignment: ; in, are the trainable weight matrices for text, speech, and diagrams, respectively. is the Sigmoid activation function, For Hadamard, is the text embedding feature vector, is the speech embedding feature vector, is the schematic embedding feature vector, is the cross-modal feature vector.

[0017] The above cross-modal alignment formula is used to achieve weighted importance between modalities and solve the problem of differences in the representation of heterogeneous data.

[0018] Step 1-2: Through the core intent extraction network, monitor and identify key demand nodes from the above user input intent. Based on the hierarchical extractor of the multi-head attention mechanism, calculate the demand intent focus weight ; in, , , are the query, key, and value matrices in the input intent and requirement documents, respectively. is the scaling factor; , , The weights of query, key and value are respectively. The multi-dimensional semantic features can be captured in parallel through 8 attention heads to output the intention vector .

[0019] Steps 1-3: Perform semantic intent completion and conflict detection based on domain knowledge related to the intelligent system to further clarify and format the intent. The domain knowledge graph is represented as , the entity set E contains the basic modeling concepts of artificial intelligence, and the relationship set R defines the technical associations of the artificial intelligence model. Graph convolutional networks are used for requirement completion: ; in is the relation embedding vector, For vector splicing, is a relation-specific parameter matrix that outputs the completed intent vector .

[0020] Steps 1-4: Decode the enhanced intent vector into JSON-LD format and define the conversion function to meet the structural requirements of subsequent model calculations.

[0021] ; in is the task type code, m is the set of indicators such as accuracy and delay, and c is the resource constraint.

[0022] Step 2: Based on AI intent requirements and typical AI models, dynamically build operator combinations to automatically generate standard workflows suitable for AI tasks. The specific sub-steps are as follows: Step 2-1: Establish a multi-dimensional feature vector mapping between the demand model and technical indicators based on the orthogonal feature space. ; The required space is , the technical indicator space is , is an abstract operator feature mapping function. This feature mapping function must be orthogonalized and its feature basis must be linearly independent to eliminate dimensional coupling.

[0023] Step 2-2: Computational requirements based on the attention mechanism and operator set The matching degree, ; in is the learnable projection matrix, and the matching degree Manu The operator is included in the operator candidate component set .

[0024] Step 2-3: Based on the candidate operator set, construct a directed acyclic graph (DAG) of the AI ​​task, define the topological sorting objective function, and map the workflow into an operator sequence.

[0025] ; in For all permutations and combinations, Compute the interface compatibility between operators. Use dynamic programming to solve the optimal node sequence and generate the initial workflow.

[0026] Step 3: Render and visualize the workflow generated above to build an editable workflow, which includes the following sub-steps: Step 3-1: Define the node rendering equation based on the interactive React-Flow process framework: ; Based on this, visual semantic encoding is constructed to improve the interpretability of flowcharts.

[0027] Step 3-2: Design a hybrid configuration panel, provide a node parameter panel and a connection line configurator, and support probabilistic constraints on numerical parameters: ; in is the node parameter range, Configure the mean and variance of the statistics for the history.

[0028] Step 3-3: Use the improved Three-way merge algorithm to resolve topology conflicts and implement topology structure version control ; in is the graph edit distance, To punish the ring structure, λ is the balance factor to ensure the validity of the merged DAG.

[0029] Step 4: Based on the basic model and visualization results, manually intervene in the visualization panel to adjust the workflow. Optimize the model topology and workflow through data flow verification. This includes the following sub-steps: Step 4-1: Generate a workflow based on visualization, and adjust node-level hyperparameters by dragging and dropping and setting parameters. Slider controls can be used to adjust parameter range constraints. The formula editor supports advanced users to input parameter associations. The system verifies the legitimacy of parameters in real time and renders the impact prediction curve.

[0030] Step 4-2: Use the drag-and-drop component library to replace the workflow substructure module. The replacement rule is for the target node , whose input edge set Need to meet ,in Enter the dimensions for the new component. The system automatically performs an interface compatibility check and marks any connection lines with mismatched types in red.

[0031] Step 4-3: Construct a real-time data dependency graph G=(V,E,W), where the vertex V represents the computing node, the edge E is the data pipeline, and the weight The sensitivity of the output to the input. When the user modifies the topology, the system calculates the Jacobian matrix J = det(∂W / ∂θ) to evaluate the impact of the adjustment, where θ is the modified parameter.

[0032] Step 5: Perform layered testing and verification on the computational graph model generated above. The sub-steps are as follows: Step 5-1: Build a sandbox environment based on containers, create an isolated test copy, and define the environment image M = ⟨F,D,S>, where F is the workflow snapshot, D is the test dataset, and S is the resource quota. Use containerization technology to clone the environment in seconds and ensure resource isolation.

[0033] Step 5-2: For Node , according to the injection probability Input data, where is the path criticality coefficient, and α is the attenuation factor. The system prioritizes testing critical path nodes. , automatically generate boundary cases.

[0034] Step 5-3: Based on the test verification results, conduct a multi-dimensional evaluation and calculate its comprehensive performance indicators: , where A is the accuracy, T is the delay, and R is the memory consumption. is the weight coefficient .

[0035] Step 6: Based on the inference experiment results, the model is automatically iterated and optimized. The sub-steps are as follows: Step 6-1: Use differential evolution to optimize node parameters. Specifically, first generate mutation vectors based on mutations. ) ; Where F∈[0,2] is the scaling factor, r1, r2, r3 are random indices; The data generated for r1 iteration, The data generated for the r2 iteration, Data generated for the r3 iteration.

[0036] Then use cross validation to generate the test vector ; Among them, CR∈[0,1] is the crossover probability, is the i-th and j-th cross iteration vector, Generate mutation vectors for the i-th and j-th crossover iterations.

[0037] Finally, the better solution is retained by selection , Among them, U and V are fixed-point data sets, and Q is the iterative profit function.

[0038] Step 6-2: Build a data validation set for feedback-driven updates.

[0039] Among them, the verification data set builds the database storage structure: ,in is the parameter gradient, X i is the data of the i-th node, and Q is the iterative benefit.

[0040] When new data arrives, trigger the parameter update: , η is the learning rate.

[0041] Step 6-3: When the model accuracy decreases, the automatic rollback mechanism is triggered and the model is automatically restored to the historical optimal version.

[0042] Step 7: Perform end-to-end optimization on the generated model and deploy it for release: Step 7-1: Run the following process compression algorithm to calculate node redundancy and prune to eliminate redundant nodes: ; Among them, O is the original output, O' is the removed After output; when When , it is marked as a redundant node, and the topological connectivity is verified after pruning.

[0043] Step 7-2: Deploy parallel pipelines, shard traffic to different models, and perform stress testing and comparison. The comparison indicators are: ; The error in the new shard deployment plan. The error in the original allocation deployment plan.

[0044] When the error indicator remains <2% for more than three cycles, the production environment switch is triggered.

[0045] Step 7-3: Generate an evaluation report (confusion matrix / ROC curve) and generate API interface specifications

[0046] Where I is the input mode, O is the output structure, S is the service level agreement, and L is the request limit per second; Automatically generate API documentation and SDK toolkit.

[0047] After experimental testing and verification, the present invention reduces repeated configuration operations compared with traditional solutions and increases the model iteration speed by 2.1 times.

[0048] Finally, it should be noted that the above specific implementation methods are only used to illustrate the technical solutions of the present invention and are not limiting. Although the present invention has been described in detail with reference to the preferred embodiments, those skilled in the art should understand that the technical solutions of the present invention may be modified or replaced by equivalents without departing from the spirit and scope of the technical solutions of the present invention, which should all be included in the scope of the claims of the present invention.

Claims

1. A zero-code end-to-end artificial intelligence model development system based on user intent, characterized by: The method of developing a system to build an application model for a user includes the following steps: Perform intent analysis and completion based on the intelligent system development requirements input by users; Based on AI intent requirements and typical AI models, dynamically build operator combinations and automatically generate standard workflows suitable for AI tasks; Rendering and visualizing the standard workflow to construct a visual editing workflow; Through a visual interface, manual intervention is provided to adjust the workflow, and the model topology and workflow are optimized through data flow verification; Perform hierarchical testing and verification on the generated computational graph model; Based on the results of the inference experiment, the model is automatically iteratively optimized.

2. The user intent-based zero-code end-to-end artificial intelligence model development system according to claim 1 is characterized in that: The method for performing intent parsing and completion based on the intelligent system development requirements input by the user includes: Parsing user interaction multimodal input through multimodal intent, Identify key demand nodes in user input intention monitoring, Perform semantic intent completion and conflict detection based on domain knowledge related to the intelligent system to generate formatted intent; Convert formatting intent into the structured intent requirements required by the application model.

3. The user intent-based zero-code end-to-end artificial intelligence model development system according to claim 1 is characterized in that: The manual intervention adjustment includes adjusting the topology structure, configuring node hyperparameters and optimizing data flow.

4. The user intent-based zero-code end-to-end artificial intelligence model development system according to claim 2 is characterized in that: The manual intervention adjusts the workflow and optimizes the model topology and workflow through data flow verification, including the following steps: Node-level hyperparameter adjustment is performed through drag-and-drop and parameter setting. Advanced users can enter parameter associations through the formula editor. The system verifies the legitimacy of parameters in real time and renders the impact prediction curve. Use the drag-and-drop component library to replace workflow substructure modules; When users modify the model topology, the system calculates the data dependency graph in real time to assess the impact of the adjustment.

5. The user intent-based zero-code end-to-end artificial intelligence model development system according to claim 1 is characterized in that: The layered testing and verification of the generated computational graph model includes: Build a sandbox environment based on containers, create isolated test copies, and define environment images; Prioritize test path nodes by path criticality and automatically generate edge cases; Based on the test verification results, a multi-dimensional evaluation is conducted to calculate its comprehensive performance indicators.

6. The user intent-based zero-code end-to-end artificial intelligence model development system according to claim 1 is characterized in that: The automatic iterative optimization of the model comprises the following steps: Use differential evolution algorithm to optimize node parameters; Build a data validation set for feedback-driven updates; When the model accuracy decreases, the automatic rollback mechanism is triggered and the model is automatically restored to the historical optimal version.

7. The user intent-based zero-code end-to-end artificial intelligence model development system according to claim 1 is characterized in that: After automatically iteratively optimizing the model, the development system performs end-to-end optimization on the generated model.

8. The user intent-based zero-code end-to-end artificial intelligence model development system according to claim 7, characterized in that: The end-to-end optimization of the generated model comprises the following steps: Eliminate redundant computing nodes through process compression technology; Deploy parallel pipelines, split traffic into different models, and perform stress testing and comparison; Generate evaluation reports, API interface documents and SDK toolkits.

Images