Low-code automatic generation and deployment system for artificial intelligence large model development

Abstract

The invention discloses an artificial intelligence large model development-oriented low-code automatic generation and deployment system, which comprises the following steps of: performing semantic analysis on a natural language modeling demand input by a user, generating a structured modeling target, and constructing and optimizing a task flow chart. The system generates a corresponding low-code modeling instruction according to the optimized task flow chart, completes automatic matching of tasks and resources by adopting an improved shortest completion time scheduling algorithm in combination with the real-time state of heterogeneous computing resources, and automatically deploys the generated modeling tasks to a target computing environment in a containerization manner, so that the modeling efficiency is improved. And unified operation control and process monitoring are carried out, so that automatic closed loop from semantic input to model deployment is realized.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence model development and software automation technology, and in particular to a low-code automated generation and deployment system for the development of large artificial intelligence models. Background Art

[0002] With the widespread application of large-scale AI modeling technology, the model development process is becoming increasingly complex, encompassing multiple stages from requirements analysis, model building, resource scheduling to final deployment. Large-scale AI models exhibit highly heterogeneous and dynamically changing characteristics in terms of computing power consumption, structural design, and task dependencies, placing higher demands on development efficiency and system integration capabilities. However, current mainstream large-scale modeling development processes rely on manual modeling, script-based orchestration, and static deployment, which suffer from operational complexity and low efficiency, severely hindering the rapid implementation and widespread application of large-scale modeling technology.

[0003] While some low-code development platforms and automated deployment tools have emerged in the current technology, they are mostly limited to general software processes or lightweight model development scenarios, making it difficult to adapt to the high complexity of large-scale artificial intelligence models. Specifically, existing technologies have significant shortcomings in the following aspects:

[0004] 1. Lack of semantic-driven modeling mechanism: Existing low-code tools usually adopt a template-driven approach, which cannot automatically understand the user's modeling intent and large model structure requirements from natural language.

[0005] 2. The modeling process is organized in a crude manner: Traditional modeling processes often adopt a linear task arrangement method, which lacks task graph structure and graph optimization mechanism, resulting in suboptimal task execution paths and serious node redundancy.

[0006] 3. Lack of intelligence and dynamic adaptability in resource scheduling: Existing deployment methods often fail to perceive the computing power requirements and resource status of task nodes, and lack efficient scheduling algorithms to support them in heterogeneous computing environments.

[0007] 4. Fragmented and untraceable deployment process: Existing systems mostly use manual operation or script-based control, with the deployment process being separated from the front-end modeling instructions, lacking semantic link tracing and integrated closed-loop execution capabilities.

[0008] Therefore, how to provide a low-code automated generation and deployment system for developing large-scale artificial intelligence models is a problem that urgently needs to be solved by those skilled in the art. Summary of the Invention

[0009] One objective of this invention is to propose a low-code automated generation and deployment system for the development of large-scale artificial intelligence models. This invention employs technologies such as semantic parsing, task graph modeling, graph structure optimization, low-code instruction generation, heterogeneous resource scheduling, and containerized deployment to construct an automated process from natural language input to model deployment and execution. It has the advantages of low technical threshold, high modeling efficiency, intelligent resource matching, and traceable deployment process.

[0010] The low-code automated generation and deployment system for developing large-scale artificial intelligence models according to embodiments of the present invention includes the following steps:

[0011] The natural language parsing module is used to receive the natural language modeling requirement text input by the user and call the intent recognition network trained based on a large language model to convert the natural language modeling requirement text into a structured modeling target.

[0012] The task flow modeling module is used to construct task flow diagrams based on structured modeling objectives and establish topological connections between task nodes according to preset data dependency rules and execution order.

[0013] The flowchart optimization module is used to perform structural optimization operations on the task flowchart, adjust the connection order between task nodes, merge nodes with duplicate functions, and generate an optimized task flowchart.

[0014] The low-code instruction generation module is used to map each modeling task node in the optimized task flowchart to a low-code instruction template. The low-code instruction template is derived from a predefined large model component library and binds semantic tags and execution dependency information during the instruction generation process to generate an executable low-code instruction set.

[0015] The resource scheduling module is used to evaluate the available computing power of each computing node in the heterogeneous computing resource pool based on the node execution resource requirements recorded in the low-code instruction set, call the deployment objective function constructed by the improved shortest completion time scheduling algorithm, and generate a mapping table between modeling task nodes and computing resources.

[0016] The automatic deployment module takes low-code instruction sets and mapping tables as input, builds containerized deployment units, and distributes these units to target computing resource nodes for execution.

[0017] Optionally, modules can be integrated using the following methods:

[0018] S1. Receive the natural language modeling requirement text input by the user, perform syntactic analysis and semantic modeling using the natural language parsing module, and convert the natural language modeling requirement text into a structured modeling target. The structured modeling target includes the model type, network structure template identifier, data path and computing power requirement information of the large artificial intelligence model.

[0019] S2. Based on the structured modeling objectives, the task flow modeling module is called to construct a task flow diagram. The task flow diagram consists of data loading nodes, data processing nodes, model building nodes, model training nodes, and model deployment nodes. The topological connection structure between task nodes is set based on modeling semantics and dependencies.

[0020] S3. Perform task flowchart optimization operations. Based on the execution priority of task nodes and the dependency path relationship between nodes, adjust the structure of the task flowchart, including sequence reconstruction and node merging, to generate an optimized task flowchart.

[0021] S4. Based on the functional type, configuration parameters and structural information of each task node in the optimized task flowchart, generate a low-code instruction set. Match the low-code instruction set with the predefined model component library and bind the semantic tags and execution dependencies of the task nodes.

[0022] S5. Obtain real-time availability information of the heterogeneous computing resource pool, assess the resource demand indicators of each node, call the scheduling strategy to generate the mapping relationship between task nodes and computing resources, and construct the scheduling strategy based on the improved shortest completion time scheduling algorithm.

[0023] S6. Generate corresponding deployment units based on the mapping relationship between low-code instruction sets and computing resources. The deployment units encapsulate each task node in a containerized structure and complete automatic deployment and operation control on the target computing node.

[0024] Optionally, S1 specifically includes:

[0025] S11. Receive the natural language modeling requirement text input by the user, perform sentence segmentation and word segmentation on the natural language modeling requirement text, and extract and form a set of semantic units;

[0026] S12. Call the semantic recognition model trained by the large language model to perform context encoding on the semantic unit set, generating a semantic representation vector sequence, defined as h = [h1, h2, ..., h n ], where h i Represents the context embedding representation of the i-th semantic unit;

[0027] S13. Input the semantic representation vector sequence into the intent recognition network, extract the target behavior, model type entity, configuration qualifier and operation verb in the task expression through the multi-head attention mechanism, perform semantic slot filling operation, and generate the modeling intent representation.

[0028] S14. Input the modeling intent representation into the semantic mapping matching model, and match it with the modeling semantic template through the semantic matching strategy to identify the model type identifier, network structure template encoding, data source path and computing resource representation parameters of the large artificial intelligence model.

[0029] S15. Construct a structured modeling objective based on the matching results. The structured modeling objective is defined as M = (T, S, D, R) in the form of a quadruple, where T represents the model type of the large artificial intelligence model, S represents the network structure template identifier of the large artificial intelligence model, D represents the data path, and R represents the resource configuration parameters.

[0030] Optionally, S2 specifically includes:

[0031] S21. Receive the structured modeling target, and based on the model type, structure template identifier, data path and resource configuration parameters, call the task flow modeling module to initialize the flowchart and build the process;

[0032] S22. Extract the standard modeling process node set from the structural template identifier and construct the initial node set V = v1, v2, ..., v i Each node v i Each node corresponds to a functional task unit, and the node types include data loading, data processing, model building, model training, and model deployment.

[0033] S23. Based on the dependency logic and sequence description in the structured modeling objective, parse the execution relationships between nodes and construct the edge set E = (v i ,v j ), where v i to v j Represents task node v j Depends on node v i The output data;

[0034] S24. Combine the initial node set V and edge set E to construct a directed acyclic graph structure G = (V, E), which is defined as the task flowchart;

[0035] S25. Execute the topology connection setting rules. If there are two or more nodes with shared data dependencies, establish parallel edge connections between the data source node and all dependent nodes. If a node depends on the combined output of multiple input nodes, establish an aggregated connection.

[0036] Optionally, S3 specifically includes:

[0037] S31. Receive the task flow graph G = (V, E) output by the task flow modeling module, where V is the set of task nodes and E is the set of task dependency edges, and initialize the task flow graph optimization operation.

[0038] S32. Based on the functional type and resource requirements of each task node in the structured modeling objective, call the priority evaluation function to calculate the execution priority of the task nodes and construct a priority vector P = [p1, p2, ..., p i ], where p i Represents node v i Priority score;

[0039] S33. Based on the priority vector and task dependency path, perform a structural rearrangement operation on the task flowchart, adjust the order of nodes in the execution path, and execute nodes with higher priority than other nodes and no pre-constraints first.

[0040] S34. Identify task nodes with duplicate functions in the task flowchart. If there are two nodes v i and v j If nodes are functionally equivalent and their dependency paths can be merged, then perform a node merging operation, merging node v. j Reconnect the incoming and outgoing edges to node v i Update the task flowchart structure;

[0041] S35. Detect invalid paths in the task flowchart. If a task node has no dependency on the final model output and is not referenced by other nodes, remove the node and related edges from the node set V and the edge set E.

[0042] S36. Output the optimized task flowchart as the optimized task flowchart.

[0043] Optionally, S34 specifically includes:

[0044] S341. Traverse all task node pairs (v...) in the task flowchart G = (V, E). i ,v j ), determine task node v i With task node v j Whether it has functional equivalence is determined based on three consistency conditions: node operation type, parameter configuration, and input / output data structure.

[0045] S342. Define a function to determine functional equivalence:

[0046] F(v i ,v j )=f t ∧f p ∧f d ;

[0047] Among them, f t Indicates that the operation types are the same, f p This indicates that the parameter vectors are the same, f dThis indicates that the input and output data structures are consistent. If F(v) i ,v j If ) = true, then it is considered a functionally equivalent node pair;

[0048] S343, Determine task node v i With task node v j Does the connection topology of node v have a mergeable relationship, satisfying the following condition: i With node v j It has at least one identical predecessor node, and all its direct successor nodes are contained in the set representation.

[0049] S344. Perform a node merge operation to preserve node v. i As the master node, make node v j All incoming edges are redirected to node v i At the same time, node v j All outgoing edges are also redirected to node v i Update the node v involved in the edge set E. j Connect all edges;

[0050] S345. Remove node v from task node set V. j Remove all edges originating from node v from the task edge set E. j The original edge records are used to complete the node merging and update process.

[0051] Optionally, S4 specifically includes:

[0052] S41. Receive the optimized task flowchart, extract the function type, configuration parameters and structural information of each task node in the task flowchart, and construct the task node input tuple.

[0053] S42. Input the task node input tuple into the low-code instruction generation module, call the low-code instruction generation module to access the predefined model component library, retrieve the template set that matches the function type in the predefined model component library, and perform parameter mapping operation to map the configuration parameters to the instruction template input field in the template set to obtain the candidate instruction fragment set.

[0054] S43. Call the structure matching function in the low-code instruction generation module to perform structure information matching judgment on each candidate instruction fragment in the candidate instruction fragment set. Based on the structure compatibility matching degree function between the structure information and the output structure definition of the candidate instruction fragment, filter the candidate instruction fragments that meet the structure compatibility threshold conditions as the final instruction fragments.

[0055] S44. Bind the final instruction fragment with the task node identifier of the corresponding task node and the task dependency relationship in the task flowchart to form a low-code instruction unit;

[0056] S45. Summarize the low-code instruction units corresponding to all task nodes to form a low-code instruction set.

[0057] Optionally, S5 specifically includes:

[0058] S51. Obtain real-time operating status information of the heterogeneous computing resource pool, which includes cloud server nodes, edge computing nodes and terminal device nodes. Collect the current available computing power, storage capacity, network bandwidth and task queue length of each computing resource node to form a resource status matrix.

[0059] S52. Extract the execution resource requirement information of each task node from the low-code instruction set. The execution resource requirement information includes computational load indicators, memory usage indicators and data input / output rate requirements. Construct a task resource requirement vector set.

[0060] S53. Input the resource status matrix and the task resource requirement vector set into the resource scheduling module, call the improved shortest completion time scheduling algorithm in the resource scheduling module, and sort the scheduling priority according to the expected completion time of each task node on different computing resource nodes.

[0061] S54. In the improved shortest completion time scheduling algorithm, define each task node v i In computing resource node r j Expected completion time T ij for:

[0062]

[0063] Among them, C i Represents task node v i The computational cost, P j Represents the computing resource node r j Q's processing power j Indicates the current task's queue waiting time;

[0064] S55. Based on minimizing the global completion time as the objective function, select computing resource nodes that meet the resource requirement constraints and assign target execution nodes to each task node, generate a one-to-one mapping table between task nodes and computing resource nodes, and output the mapping table to the automatic deployment module.

[0065] Optionally, the improved shortest completion time scheduling algorithm specifically includes:

[0066] For each task node vi Calculate its value on each available computing resource node r j The estimated completion time T ij ;

[0067] Introducing a task priority weighting factor W i Based on the urgency of the task, the level of task dependency, and the complexity of resource requirements, a weighted scheduling priority evaluation function F is constructed. ij The evaluation function is defined as: F ij =W i ·T ij ;

[0068] For all task nodes v i In all computing resource nodes r j The weighted scheduling priority evaluation F is calculated separately above. ij Values, sorted, and then the corresponding weighted scheduling priority evaluation F is selected. ij The smallest computing resource node, as task node v i The target deployment node;

[0069] After allocating the current task node, update the status information of the computing resource node, including the current queuing time and task load.

[0070] The above steps are iterated for all task nodes to be scheduled until all task nodes have completed the allocation of resource nodes, generating a complete mapping table between task nodes and computing resource nodes.

[0071] Optionally, S6 specifically includes:

[0072] S61. Receive the mapping table between the low-code instruction set and the task nodes and computing resource nodes, logically group them according to the functional type and dependency information of the task nodes, and generate a deployment unit configuration list.

[0073] S62. For each task node in the deployment unit configuration list, build a corresponding containerized deployment unit. The deployment unit encapsulates low-code instructions, runtime dependencies, version identifiers and task metadata information to form a unified deployment image structure.

[0074] S63. Generate a scheduling control script for each containerized deployment unit. The scheduling control script includes the deployment node address, initialization command sequence, resource request parameters, and execution entry function. The execution entry function is generated by the top-level task flow definition in the low-code instruction set.

[0075] S64. Based on the mapping table, the deployment engine is invoked to distribute each containerized deployment unit to its corresponding target computing resource node, and the execution of the scheduling control script is triggered by remote command invocation.

[0076] S65. After deployment, monitor the container running status and task execution progress on each computing resource node, and collect running logs and performance indicators for subsequent operation control and optimization strategy input.

[0077] The beneficial effects of the present invention are:

[0078] (1) By constructing a natural language parsing module and a task flow modeling module, and combining a task flow diagram generation method based on graph structure optimization, this invention significantly reduces the operational complexity and professional threshold in the development of large artificial intelligence models, realizes the automatic conversion from semantic input to modeling structure, and improves the generation accuracy and structural rationality of modeling tasks through the fusion processing of multi-dimensional semantic vectors, node dependency relationships and task priority information.

[0079] (2) By integrating a low-code instruction generation module and a predefined model component library, this invention achieves parameter adaptation, structure matching and instruction binding for different modeling task nodes, automatically completes the calling and control logic generation of model components, improves development efficiency and ensures instruction traceability and process integrity; combined with structural information filtering and dependency binding strategies, it effectively reduces the occurrence of redundant instructions and logic conflicts.

[0080] (3) This invention introduces an improved shortest completion time scheduling algorithm, constructs a task priority weighted scheduling function, and matches the task resource requirements with the status of heterogeneous computing nodes to achieve an efficient, dynamic, and adaptive resource scheduling strategy, which improves the overall task execution efficiency of the system and supports flexible scheduling and deployment of model tasks in cloud, edge, and terminal environments.

[0081] (4) By generating containerized deployment units and combining deployment control scripts with node mapping tables, this invention achieves full automation of deployment operations, supports closed-loop execution of low-code instructions to container encapsulation, remote resource invocation, task registration and deployment monitoring, and ensures the consistency, stability and controllability of model deployment, effectively overcoming the problem of fragmentation and inability to automatically coordinate the various stages of modeling, scheduling and deployment in the traditional development process. Attached Figure Description

[0082] The accompanying drawings are provided to further illustrate the invention and form part of the specification. They are used in conjunction with embodiments of the invention to explain the invention and do not constitute a limitation thereof. In the drawings:

[0083] Figure 1 The flowchart shows the low-code automated generation and deployment method for developing large artificial intelligence models proposed in this invention.

[0084] Figure 2This is an architecture diagram of the low-code automated generation and deployment system for developing large-scale artificial intelligence models proposed in this invention;

[0085] Figure 3 This is a schematic diagram of the task-resource matching calculation of the improved shortest completion time scheduling algorithm in this invention. Detailed Implementation

[0086] The present invention will now be described in further detail with reference to the accompanying drawings, which are simplified schematic diagrams that illustrate the basic structure of the present invention in a schematic manner.

[0087] refer to Figure 1-3 A low-code automated generation and deployment system for developing large-scale artificial intelligence models includes the following steps:

[0088] The natural language parsing module is used to receive the natural language modeling requirement text input by the user and call the intent recognition network trained based on a large language model to convert the natural language modeling requirement text into a structured modeling target.

[0089] The task flow modeling module is used to construct task flow diagrams based on structured modeling objectives and establish topological connections between task nodes according to preset data dependency rules and execution order.

[0090] The flowchart optimization module is used to perform structural optimization operations on the task flowchart, adjust the connection order between task nodes, merge nodes with duplicate functions, and generate an optimized task flowchart.

[0091] The low-code instruction generation module is used to map each modeling task node in the optimized task flowchart to a low-code instruction template. The low-code instruction template is derived from a predefined large model component library and binds semantic tags and execution dependency information during the instruction generation process to generate an executable low-code instruction set.

[0092] The resource scheduling module is used to evaluate the available computing power of each computing node in the heterogeneous computing resource pool based on the node execution resource requirements recorded in the low-code instruction set, call the deployment objective function constructed by the improved shortest completion time scheduling algorithm, and generate a mapping table between modeling task nodes and computing resources.

[0093] The automatic deployment module takes low-code instruction sets and mapping tables as input, builds containerized deployment units, and distributes these units to target computing resource nodes for execution.

[0094] In this embodiment, the modules are interconnected using the following method:

[0095] S1. Receive the natural language modeling requirement text input by the user, perform syntactic analysis and semantic modeling using the natural language parsing module, and convert the natural language modeling requirement text into a structured modeling target. The structured modeling target includes the model type, network structure template identifier, data path and computing power requirement information of the large artificial intelligence model.

[0096] S2. Based on the structured modeling objectives, the task flow modeling module is called to construct a task flow diagram. The task flow diagram consists of data loading nodes, data processing nodes, model building nodes, model training nodes, and model deployment nodes. The topological connection structure between task nodes is set based on modeling semantics and dependencies.

[0097] S3. Perform task flowchart optimization operations. Based on the execution priority of task nodes and the dependency path relationship between nodes, adjust the structure of the task flowchart, including sequence reconstruction and node merging, to generate an optimized task flowchart.

[0098] S4. Based on the functional type, configuration parameters and structural information of each task node in the optimized task flowchart, generate a low-code instruction set. Match the low-code instruction set with the predefined model component library and bind the semantic tags and execution dependencies of the task nodes.

[0099] S5. Obtain real-time availability information of the heterogeneous computing resource pool, assess the resource demand indicators of each node, call the scheduling strategy to generate the mapping relationship between task nodes and computing resources, and construct the scheduling strategy based on the improved shortest completion time scheduling algorithm.

[0100] S6. Generate corresponding deployment units based on the mapping relationship between low-code instruction sets and computing resources. The deployment units encapsulate each task node in a containerized structure and complete automatic deployment and operation control on the target computing node.

[0101] In this embodiment, S1 specifically includes:

[0102] S11. Receive the natural language modeling requirement text input by the user, perform sentence segmentation and word segmentation on the natural language modeling requirement text, and extract and form a set of semantic units;

[0103] S12. Call the semantic recognition model trained by the large language model to perform context encoding on the semantic unit set, generating a semantic representation vector sequence, defined as h = [h1, h2, ..., h n ], where h i Represents the context embedding representation of the i-th semantic unit;

[0104] S13. Input the semantic representation vector sequence into the intent recognition network, extract the target behavior, model type entity, configuration qualifier and operation verb in the task expression through the multi-head attention mechanism, perform semantic slot filling operation, and generate the modeling intent representation.

[0105] S14. Input the modeling intent representation into the semantic mapping matching model, and match it with the modeling semantic template through the semantic matching strategy to identify the model type identifier, network structure template encoding, data source path and computing resource representation parameters of the large artificial intelligence model.

[0106] S15. Construct a structured modeling objective based on the matching results. The structured modeling objective is defined as M = (T, S, D, R) in the form of a quadruple, where T represents the model type of the large artificial intelligence model, S represents the network structure template identifier of the large artificial intelligence model, D represents the data path, and R represents the resource configuration parameters.

[0107] This implementation extracts semantic units, encodes context, identifies intent, and fills semantic slots in the user-input natural language modeling requirement text. It then utilizes a large language model and multi-head attention mechanisms to extract key semantic elements of the modeling task. A semantic mapping matching model is used to match these elements with a modeling semantic template, identifying the model type, structural template, data path, and computational requirements. Finally, a structured modeling target quadruple is constructed. This approach achieves accurate conversion of natural language into modeling structural information, effectively bridging the semantic gap between user intent and technical configuration, and improving the automation and standardization of modeling task expression in the large-scale AI model development process.

[0108] In this embodiment, S2 specifically includes:

[0109] S21. Receive the structured modeling target, and based on the model type, structure template identifier, data path and resource configuration parameters, call the task flow modeling module to initialize the flowchart and build the process;

[0110] S22. Extract the standard modeling process node set from the structural template identifier and construct the initial node set V = v1, v2, ..., v i Each node v i Each node corresponds to a functional task unit, and the node types include data loading, data processing, model building, model training, and model deployment.

[0111] S23. Based on the dependency logic and sequence description in the structured modeling objective, parse the execution relationships between nodes and construct the edge set E = (v i ,v j ), where v i to v j Represents task node v j Depends on node vi The output data;

[0112] S24. Combine the initial node set V and edge set E to construct a directed acyclic graph structure G = (V, E), which is defined as the task flowchart;

[0113] S25. Execute the topology connection setting rules. If there are two or more nodes with shared data dependencies, establish parallel edge connections between the data source node and all dependent nodes. If a node depends on the combined output of multiple input nodes, establish an aggregated connection.

[0114] This implementation receives a structured modeling target, extracts model types, structural templates, data paths, and resource configuration parameters related to the development of large-scale artificial intelligence models, automatically invokes the task flow modeling module to initialize the flowchart, and extracts a set of standard task nodes from the structural template identifier to construct an initial node set including data loading, preprocessing, construction, training, and deployment. It further parses the logic and data dependencies between tasks, generates directed connections between tasks, and ultimately forms a directed acyclic task flowchart structure with parallelism and aggregation. This flowchart construction method not only ensures the correctness of the task sequence but also possesses topological flexibility and data flow expression capabilities, providing a unified structural foundation for subsequent flowchart optimization, instruction generation, and resource scheduling, effectively improving the clarity of the modeling task flow and the degree of modeling automation.

[0115] In this embodiment, S3 specifically includes:

[0116] S31. Receive the task flow graph G = (V, E) output by the task flow modeling module, where V is the set of task nodes and E is the set of task dependency edges, and initialize the task flow graph optimization operation.

[0117] S32. Based on the functional type and resource requirements of each task node in the structured modeling objective, call the priority evaluation function to calculate the execution priority of the task nodes and construct a priority vector P = [p1, p2, ..., p i ], where p i Represents node v i Priority score;

[0118] S33. Based on the priority vector and task dependency path, perform a structural rearrangement operation on the task flowchart, adjust the order of nodes in the execution path, and execute nodes with higher priority than other nodes and no pre-constraints first.

[0119] S34. Identify task nodes with duplicate functions in the task flowchart. If there are two nodes v i and v jIf nodes are functionally equivalent and their dependency paths can be merged, then perform a node merging operation, merging node v. j Reconnect the incoming and outgoing edges to node v i Update the task flowchart structure;

[0120] S35. Detect invalid paths in the task flowchart. If a task node has no dependency on the final model output and is not referenced by other nodes, remove the node and related edges from the node set V and the edge set E.

[0121] S36. Output the optimized task flowchart as the optimized task flowchart.

[0122] This implementation method constructs an initial task flowchart based on the structured modeling objective. It uses a priority evaluation function to sort task nodes and rearranges the flowchart structure in conjunction with task dependency paths, improving execution efficiency while preserving logical correctness. By identifying functionally equivalent task nodes with mergeable paths, it achieves node merging and connection redirection, eliminating redundant calculations. Furthermore, it detects and removes invalid paths and isolated nodes, outputting a compact and path-optimized task flowchart, effectively improving task scheduling efficiency and process execution stability. This provides a high-quality input foundation for subsequent low-code instruction generation and resource scheduling, enhancing the system's adaptability and execution performance in complex modeling processes.

[0123] In this embodiment, S34 specifically includes:

[0124] S341. Traverse all task node pairs (v...) in the task flowchart G = (V, E). i ,v j ), determine task node v i With task node v j Whether it has functional equivalence is determined based on three consistency conditions: node operation type, parameter configuration, and input / output data structure.

[0125] S342. Define a function to determine functional equivalence:

[0126] F(v i ,v j )=f t ∧f p ∧f d ;

[0127] Among them, f t Indicates that the operation types are the same, f p This indicates that the parameter vectors are the same, f d This indicates that the input and output data structures are consistent. If F(v) i ,v jIf ) = true, then it is considered a functionally equivalent node pair;

[0128] This formula is used to determine whether two task nodes are functionally equivalent. It constructs a logical AND relationship based on three conditions: consistent operation type, consistent parameter configuration, and consistent input / output data structure. Only when all three conditions are met are the two nodes considered functionally equivalent. The principle behind this formula is to structurally abstract the key features of task nodes and use logical functions to strictly constrain the merging conditions between nodes. This ensures that the flowchart after node merging maintains consistency in functional semantics and data dependencies, avoiding confusion in task execution logic or deviations in results due to incorrect merging.

[0129] S343, Determine task node v i With task node v j Does the connection topology of node v have a mergeable relationship, satisfying the following condition: i With node v j It has at least one identical predecessor node, and all its direct successor nodes are contained in the set representation.

[0130] S344. Perform a node merge operation to preserve node v. i As the master node, make node v j All incoming edges are redirected to node v i At the same time, node v j All outgoing edges are also redirected to node v i Update the node v involved in the edge set E. j Connect all edges;

[0131] S345. Remove node v from task node set V. j Remove all edges originating from node v from the task edge set E. j The original edge records are used to complete the node merging and update process.

[0132] This implementation optimizes the task node structure by traversing all task node pairs in the task flowchart, sequentially determining their consistency in operation type, parameter configuration, and input / output data structure, constructing a functional equivalence judgment function, and identifying mergeable nodes based on topological relationships. Finally, it performs edge connection redirection and redundant node removal. This method reduces redundant nodes and invalid paths in the flowchart while ensuring the integrity of task functionality, simplifies the modeling structure, improves the efficiency of instruction generation and resource scheduling, and provides a more compact and clearer task flowchart structure for subsequent deployment and execution.

[0133] In this embodiment, S4 specifically includes:

[0134] S41. Receive the optimized task flowchart, extract the function type, configuration parameters and structural information of each task node in the task flowchart, and construct the task node input tuple.

[0135] S42. Input the task node input tuple into the low-code instruction generation module, call the low-code instruction generation module to access the predefined model component library, retrieve the template set that matches the function type in the predefined model component library, and perform parameter mapping operation to map the configuration parameters to the instruction template input field in the template set to obtain the candidate instruction fragment set.

[0136] S43. Call the structure matching function in the low-code instruction generation module to perform structure information matching judgment on each candidate instruction fragment in the candidate instruction fragment set. Based on the structure compatibility matching degree function between the structure information and the output structure definition of the candidate instruction fragment, filter the candidate instruction fragments that meet the structure compatibility threshold conditions as the final instruction fragments.

[0137] S44. Bind the final instruction fragment with the task node identifier of the corresponding task node and the task dependency relationship in the task flowchart to form a low-code instruction unit;

[0138] S45. Summarize the low-code instruction units corresponding to all task nodes to form a low-code instruction set.

[0139] This implementation method inputs the task node information from the optimized task flowchart into the low-code instruction generation module. Combining the functional type, configuration parameters, and structural information of the task nodes, it retrieves matching templates from the predefined model component library and generates the most suitable instruction fragments through a structural matching function. Then, it binds the instruction fragments with task identifiers and dependencies to form a complete low-code instruction set. This achieves automated generation and traceable binding of modeling instructions, effectively improving the automatic generation capability and modeling efficiency of large-scale artificial intelligence modeling, and enhancing the structural consistency and execution controllability of instruction logic.

[0140] In this embodiment, S5 specifically includes:

[0141] S51. Obtain real-time operating status information of the heterogeneous computing resource pool, which includes cloud server nodes, edge computing nodes and terminal device nodes. Collect the current available computing power, storage capacity, network bandwidth and task queue length of each computing resource node to form a resource status matrix.

[0142] S52. Extract the execution resource requirement information of each task node from the low-code instruction set. The execution resource requirement information includes computational load indicators, memory usage indicators and data input / output rate requirements. Construct a task resource requirement vector set.

[0143] S53. Input the resource status matrix and the task resource requirement vector set into the resource scheduling module, call the improved shortest completion time scheduling algorithm in the resource scheduling module, and sort the scheduling priority according to the expected completion time of each task node on different computing resource nodes.

[0144] S54. In the improved shortest completion time scheduling algorithm, define each task node v i In computing resource node r j Expected completion time T ij for:

[0145]

[0146] Among them, C i Represents task node v i The computational cost, P j Represents the computing resource node r j Q's processing power j Indicates the current task's queue waiting time;

[0147] The formula for calculating expected completion time introduced in this paper dynamically assesses the actual execution cost of each task on different resource nodes by comprehensively considering the computational load of the task, the processing capacity of the target computing resource node, and the current queuing time. The principle behind this formula is to divide the task's computational requirements by the node's processing capacity to obtain the base execution time, and then add the current queuing time of the resource node, thus reflecting the overall execution latency of the task on that node. This approach enables a unified quantitative assessment of resource utilization efficiency and scheduling latency, providing a precise numerical basis for subsequent optimal scheduling decisions, improving the rationality of resource matching and the overall scheduling performance of the system.

[0148] S55. Based on minimizing the global completion time as the objective function, select computing resource nodes that meet the resource requirement constraints and assign target execution nodes to each task node, generate a one-to-one mapping table between task nodes and computing resource nodes, and output the mapping table to the automatic deployment module.

[0149] This implementation acquires the real-time operating status of a heterogeneous computing resource pool composed of cloud server nodes, edge computing nodes, and terminal device nodes. Combined with task node resource requirement information extracted from the low-code instruction set, a resource status matrix and a task resource requirement vector set are constructed. An improved shortest completion time scheduling algorithm is introduced, incorporating task computation, resource node processing capacity, and queuing time into the expected completion time calculation model. Based on a weighted sorting mechanism, dynamic matching between task nodes and computing resource nodes is achieved, thereby minimizing the overall task completion time while ensuring resource constraints are met. This effectively improves the scheduling efficiency and deployment intelligence level of large-scale artificial intelligence model tasks in complex heterogeneous environments.

[0150] In this embodiment, the improved shortest completion time scheduling algorithm specifically includes:

[0151] For each task node v i Calculate its value on each available computing resource node r j The estimated completion time T ij ;

[0152] Introducing a task priority weighting factor W i Based on the urgency of the task, the level of task dependency, and the complexity of resource requirements, a weighted scheduling priority evaluation function F is constructed. ij The evaluation function is defined as: F ij =W i ·T ij ;

[0153] For all task nodes v i In all computing resource nodes r j The weighted scheduling priority evaluation F is calculated separately above. ij Values, sorted, and then the corresponding weighted scheduling priority evaluation F is selected. ij The smallest computing resource node, as task node v i The target deployment node;

[0154] After allocating the current task node, update the status information of the computing resource node, including the current queuing time and task load.

[0155] The above steps are iterated for all task nodes to be scheduled until all task nodes have completed the allocation of resource nodes, generating a complete mapping table between task nodes and computing resource nodes.

[0156] This implementation calculates the estimated completion time of each task node across all computing resource nodes and introduces a task priority weighting factor. It comprehensively considers the urgency, dependency level, and resource complexity of tasks to construct a weighted scheduling priority evaluation function, achieving multi-dimensional scheduling priority ranking. During scheduling, the queuing status and task load of computing resource nodes are dynamically updated, and tasks and resources are mapped and allocated one-to-one based on the global minimum weighted completion time. This method effectively improves the intelligence level of resource scheduling in heterogeneous environments, enhances the scheduling algorithm's responsiveness to high-priority and critical path tasks, and achieves a dynamic balance between task execution efficiency and resource utilization.

[0157] In this embodiment, S6 specifically includes:

[0158] S61. Receive the mapping table between the low-code instruction set and the task nodes and computing resource nodes, logically group them according to the functional type and dependency information of the task nodes, and generate a deployment unit configuration list.

[0159] S62. For each task node in the deployment unit configuration list, build a corresponding containerized deployment unit. The deployment unit encapsulates low-code instructions, runtime dependencies, version identifiers and task metadata information to form a unified deployment image structure.

[0160] S63. Generate a scheduling control script for each containerized deployment unit. The scheduling control script includes the deployment node address, initialization command sequence, resource request parameters, and execution entry function. The execution entry function is generated by the top-level task flow definition in the low-code instruction set.

[0161] S64. Based on the mapping table, the deployment engine is invoked to distribute each containerized deployment unit to its corresponding target computing resource node, and the execution of the scheduling control script is triggered by remote command invocation.

[0162] S65. After deployment, monitor the container running status and task execution progress on each computing resource node, and collect running logs and performance indicators for subsequent operation control and optimization strategy input.

[0163] This implementation constructs containerized deployment units by logically grouping the mapping relationship between low-code instruction sets and computing resources. It then generates scheduling control scripts containing node addresses, resource request parameters, and execution entry points, achieving consistent encapsulation and automatic scheduling of deployment images. The containerized deployment units are automatically distributed to target computing nodes, and deployment and execution are triggered via remote commands. Simultaneously, the system continuously monitors operational status and performance data, providing support for subsequent optimization. This approach effectively achieves standardized deployment and cross-platform automatic execution of model tasks, improving deployment efficiency, consistency, and operational controllability, and providing a unified and efficient solution for the multi-environment collaborative deployment of complex artificial intelligence models.

[0164] Example 1:

[0165] To verify the feasibility of this invention in practice, it was applied to a research project titled "Multi-Source Text-Image Fusion Generation Model" led by a key laboratory. This project, jointly implemented by a university and two large internet companies, aimed to develop a bimodal large-scale model system capable of simultaneously understanding natural language and image input. The project encompassed multiple stages, including model building, data loading, training scheduling, and cross-device deployment. The technology stack was complex, and the computing power requirements were distributed across local GPU clusters, edge testing nodes, and remote cloud platforms. Due to the large task structure, numerous technical participants, and frequent adjustments to the model structure, the existing manual configuration process suffered from low efficiency, error-prone deployment, and uneven resource allocation, necessitating an automated, intelligent, and structured development method.

[0166] In the implementation of this project, project members input multi-round modeling requirements through the natural language parsing module of this invention, such as "construct a cross-modal Transformer architecture model with an attention mechanism, with text sequences and image tensors as inputs and text summarization and image reconstruction results as outputs." The system automatically parses the task objectives and generates structured modeling objectives. The task flow modeling module automatically constructs a task flow graph based on predefined semantic templates and task node dependency rules. Nodes include modules such as "image preprocessing," "text encoding," "feature alignment," and "training scheduling." The graph optimization module performs node fusion, redundant path pruning, and priority ranking, significantly simplifying the training path.

[0167] Subsequently, based on the task node structure and parameter configuration, the system calls the low-code instruction generation module to automatically match the corresponding instruction templates in the predefined component library and generate a low-code instruction set corresponding to the function of each node. The resource scheduling module collects real-time status data of local, cloud, and edge resource pools, and combines task computation volume, resource load, and communication latency to generate resource mapping relationships for each task node using an improved shortest completion time scheduling algorithm, ultimately generating a complete deployment configuration.

[0168] The automatic deployment module constructs container image units containing model logic, environment dependencies, and control entry points based on mapping relationships and low-code instructions, and automatically distributes them to target nodes for execution. The system also simultaneously builds a runtime monitoring interface to collect information such as container runtime status, training logs, and resource usage on each deployment node, and performs performance analysis and scheduling strategy adjustments periodically.

[0169] To verify the beneficial effects of this invention, a comparative experiment was conducted with the traditional manual deployment + manual scheduling method. A total of 12 cross-modal experimental sub-models were selected, and training and deployment operations were performed on each. The experiment lasted for two weeks. During the experiment, development efficiency, deployment accuracy, training startup latency, resource scheduling balance, and performance stability were quantitatively evaluated. The results are shown in the table below:

[0170] Table 1 Comparison of the effects of the method of the present invention and the traditional manual development process.

[0171] Test metrics Traditional manual process Method of the present invention Average task flow modeling time (minutes) 46.3 12.7 Low-code instruction generation accuracy (%) Unable to generate automatically 98.2％ Task allocation balance after resource scheduling (%) 68.4 93.5 Deployment configuration error rate (per 100 times) 7.3 0.8 Average training start latency (seconds) 84.5 21.4 Total development time (hours / model) 5.6 1.8 Percentage of time the system runs stably (%) 92.1 99.3

[0172] The data results show that, after adopting the method of this invention, task modeling time is reduced by 72.5%, deployment configuration error rate is reduced by 88.9%, resource scheduling is significantly balanced, and the accuracy of low-code instruction generation is close to perfect. Especially in terms of training startup latency, because the scheduling algorithm fully considers computational pressure and communication costs, startup time has been reduced from an average of 84.5 seconds to 21.4 seconds. Total development time has also decreased significantly, saving an average of 68%. System operational stability has improved by more than 7%, demonstrating the effectiveness of the container deployment process and scheduling feedback mechanism.

[0173] In practical applications, the "image-text alignment encoding module" of a certain subtask undergoes frequent iterations, with up to 15 changes to the model structure or parameters per day, making it difficult to adapt quickly using traditional manual methods. With this invention, researchers only need to modify the modeling requirements through semantic input, and the rest of the process updates automatically, truly achieving "natural language-driven modeling" and "instruction-level automatic deployment." This ensures rapid model version verification and deployment continuity, significantly improving the efficiency and reliability of collaborative development of large models.

[0174] In summary, the implementation of this invention in real scientific research projects has demonstrated its significant effectiveness in lowering technical barriers, improving development efficiency, increasing resource utilization, and enhancing deployment stability. It also possesses strong engineering adaptability and broad promotional value.

[0175] The above description is only a preferred embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any equivalent substitutions or modifications made by those skilled in the art within the scope of the technology disclosed in the present invention, based on the technical solution and inventive concept of the present invention, should be covered within the scope of protection of the present invention.

Claims

1. A low-code automated generation and deployment system for developing large-scale artificial intelligence models, characterized in that: Includes the following modules: The natural language parsing module is used to receive the natural language modeling requirement text input by the user and call the intent recognition network trained based on a large language model to convert the natural language modeling requirement text into a structured modeling target. The task flow modeling module is used to construct task flow diagrams based on structured modeling objectives and establish topological connections between task nodes according to preset data dependency rules and execution order. The flowchart optimization module is used to perform structural optimization operations on the task flowchart, adjust the connection order between task nodes, merge nodes with duplicate functions, and generate an optimized task flowchart. The low-code instruction generation module is used to map each modeling task node in the optimized task flowchart to a low-code instruction template. The low-code instruction template is derived from a predefined large model component library and binds semantic tags and execution dependency information during the instruction generation process to generate an executable low-code instruction set. The resource scheduling module is used to evaluate the available computing power of each computing node in the heterogeneous computing resource pool based on the node execution resource requirements recorded in the low-code instruction set, call the deployment objective function constructed by the improved shortest completion time scheduling algorithm, and generate a mapping table between modeling task nodes and computing resources. The automatic deployment module takes low-code instruction sets and mapping tables as input, builds containerized deployment units, and distributes these units to target computing resource nodes for execution.

2. The low-code automated generation and deployment method for developing large-scale artificial intelligence models according to claim 1, characterized in that, The modules are connected in the following way: S1. Receive the natural language modeling requirement text input by the user, perform syntactic analysis and semantic modeling using the natural language parsing module, and convert the natural language modeling requirement text into a structured modeling target. The structured modeling target includes the model type, network structure template identifier, data path and computing power requirement information of the large artificial intelligence model. S2. Based on the structured modeling objectives, the task flow modeling module is called to construct a task flow diagram. The task flow diagram consists of data loading nodes, data processing nodes, model building nodes, model training nodes, and model deployment nodes. The topological connection structure between task nodes is set based on modeling semantics and dependencies. S3. Perform task flowchart optimization operations. Based on the execution priority of task nodes and the dependency path relationship between nodes, adjust the structure of the task flowchart, including sequence reconstruction and node merging, to generate an optimized task flowchart. S4. Based on the functional type, configuration parameters and structural information of each task node in the optimized task flowchart, generate a low-code instruction set. Match the low-code instruction set with the predefined model component library and bind the semantic tags and execution dependencies of the task nodes. S5. Obtain real-time availability information of the heterogeneous computing resource pool, assess the resource demand indicators of each node, call the scheduling strategy to generate the mapping relationship between task nodes and computing resources, and construct the scheduling strategy based on the improved shortest completion time scheduling algorithm. S6. Generate corresponding deployment units based on the mapping relationship between low-code instruction sets and computing resources. The deployment units encapsulate each task node in a containerized structure and complete automatic deployment and operation control on the target computing node.

3. The low-code automated generation and deployment method for developing large-scale artificial intelligence models according to claim 2, characterized in that, S1 specifically includes: S11. Receive the natural language modeling requirement text input by the user, perform sentence segmentation and word segmentation on the natural language modeling requirement text, and extract and form a set of semantic units; S12. Call the semantic recognition model trained by the large language model to perform context encoding on the semantic unit set, generating a semantic representation vector sequence, defined as h = [h1, h2, ..., h n ], where h i Represents the context embedding representation of the i-th semantic unit; S13. Input the semantic representation vector sequence into the intent recognition network, extract the target behavior, model type entity, configuration qualifier and operation verb in the task expression through the multi-head attention mechanism, perform semantic slot filling operation, and generate the modeling intent representation. S14. Input the modeling intent representation into the semantic mapping matching model, and match it with the modeling semantic template through the semantic matching strategy to identify the model type identifier, network structure template encoding, data source path and computing resource representation parameters of the large artificial intelligence model. S15. Construct a structured modeling objective based on the matching results. The structured modeling objective is defined as M = (T, S, D, R) in the form of a quadruple, where T represents the model type of the large artificial intelligence model, S represents the network structure template identifier of the large artificial intelligence model, D represents the data path, and R represents the resource configuration parameters.

4. The low-code automated generation and deployment method for developing large-scale artificial intelligence models according to claim 2, characterized in that, S2 specifically includes: S21. Receive the structured modeling target, and based on the model type, structure template identifier, data path and resource configuration parameters, call the task flow modeling module to initialize the flowchart and build the process; S22. Extract the standard modeling process node set from the structural template identifier and construct the initial node set V = v1, v2, ..., v i Each node v i Each node corresponds to a functional task unit, and the node types include data loading, data processing, model building, model training, and model deployment. S23. Based on the dependency logic and sequence description in the structured modeling objective, parse the execution relationships between nodes and construct the edge set E = (v i ,v j ), where v i to v j Represents task node v j Depends on node v i The output data; S24. Combine the initial node set V and edge set E to construct a directed acyclic graph structure G = (V, E), which is defined as the task flowchart; S25. Execute the topology connection setting rules. If there are two or more nodes with shared data dependencies, establish parallel edge connections between the data source node and all dependent nodes. If a node depends on the combined output of multiple input nodes, establish an aggregated connection.

5. The low-code automated generation and deployment method for developing large-scale artificial intelligence models according to claim 2, characterized in that, S3 specifically includes: S31. Receive the task flow graph G = (V, E) output by the task flow modeling module, where V is the set of task nodes and E is the set of task dependency edges, and initialize the task flow graph optimization operation. S32. Based on the functional type and resource requirements of each task node in the structured modeling objective, call the priority evaluation function to calculate the execution priority of the task nodes and construct a priority vector P = [p1, p2, ..., p i ], where p i Represents node v i Priority score; S33. Based on the priority vector and task dependency path, perform a structural rearrangement operation on the task flowchart, adjust the order of nodes in the execution path, and execute nodes with higher priority than other nodes and no pre-constraints first. S34. Identify task nodes with duplicate functions in the task flowchart. If there are two nodes v i and v j If nodes are functionally equivalent and their dependency paths can be merged, then perform a node merging operation, merging node v. j Reconnect the incoming and outgoing edges to node v i Update the task flowchart structure; S35. Detect invalid paths in the task flowchart. If a task node has no dependency on the final model output and is not referenced by other nodes, remove the node and related edges from the node set V and the edge set E. S36. Output the optimized task flowchart as the optimized task flowchart.

6. The low-code automated generation and deployment method for developing large-scale artificial intelligence models according to claim 5, characterized in that, S34 specifically includes: S341. Traverse all task node pairs (v...) in the task flowchart G = (V, E). i ,v j ), determine task node v i With task node v j Whether it has functional equivalence is determined based on three consistency conditions: node operation type, parameter configuration, and input / output data structure. S342. Define a function to determine functional equivalence: F(v i ,v j )=f t ∧f p ∧f d ; Among them, f t Indicates that the operation types are the same, f p This indicates that the parameter vectors are the same, f d This indicates that the input and output data structures are consistent. If F(v) i ,v j If ) = true, then it is considered a functionally equivalent node pair; S343, Determine task node v i With task node v j Does the connection topology of node v have a mergeable relationship, satisfying the following condition: i With node v j It has at least one identical predecessor node, and all its direct successor nodes are contained in the set representation. S344. Perform a node merge operation to preserve node v. i As the master node, make node v j All incoming edges are redirected to node v i At the same time, node v j All outgoing edges are also redirected to node v i Update the node v involved in the edge set E. j Connect all edges; S345. Remove node v from task node set V. j Remove all edges originating from node v from the task edge set E. j The original edge records are used to complete the node merging and update process.

7. The low-code automated generation and deployment method for developing large-scale artificial intelligence models according to claim 2, characterized in that, S4 specifically includes: S41. Receive the optimized task flowchart, extract the function type, configuration parameters and structural information of each task node in the task flowchart, and construct the task node input tuple. S42. Input the task node input tuple into the low-code instruction generation module, call the low-code instruction generation module to access the predefined model component library, retrieve the template set that matches the function type in the predefined model component library, and perform parameter mapping operation to map the configuration parameters to the instruction template input field in the template set to obtain the candidate instruction fragment set. S43. Call the structure matching function in the low-code instruction generation module to perform structure information matching judgment on each candidate instruction fragment in the candidate instruction fragment set. Based on the structure compatibility matching degree function between the structure information and the output structure definition of the candidate instruction fragment, filter the candidate instruction fragments that meet the structure compatibility threshold conditions as the final instruction fragments. S44. Bind the final instruction fragment with the task node identifier of the corresponding task node and the task dependency relationship in the task flowchart to form a low-code instruction unit; S45. Summarize the low-code instruction units corresponding to all task nodes to form a low-code instruction set.

8. The low-code automated generation and deployment method for developing large-scale artificial intelligence models according to claim 2, characterized in that, S5 specifically includes: S51. Obtain real-time operating status information of the heterogeneous computing resource pool, which includes cloud server nodes, edge computing nodes and terminal device nodes. Collect the current available computing power, storage capacity, network bandwidth and task queue length of each computing resource node to form a resource status matrix. S52. Extract the execution resource requirement information of each task node from the low-code instruction set. The execution resource requirement information includes computational load indicators, memory usage indicators and data input / output rate requirements. Construct a task resource requirement vector set. S53. Input the resource status matrix and the task resource requirement vector set into the resource scheduling module, call the improved shortest completion time scheduling algorithm in the resource scheduling module, and sort the scheduling priority according to the expected completion time of each task node on different computing resource nodes. S54. In the improved shortest completion time scheduling algorithm, define each task node v i In computing resource node r j Expected completion time T ij for: Among them, C i Represents task node v i The computational cost, P j Represents the computing resource node r j Q's processing power j Indicates the current task's queue waiting time; S55. Based on minimizing the global completion time as the objective function, select computing resource nodes that meet the resource requirement constraints and assign target execution nodes to each task node, generate a one-to-one mapping table between task nodes and computing resource nodes, and output the mapping table to the automatic deployment module.

9. The low-code automated generation and deployment method for developing large-scale artificial intelligence models according to claim 8, characterized in that, The improved shortest completion time scheduling algorithm specifically includes: For each task node v i Calculate its value on each available computing resource node r j The estimated completion time T ij ; Introducing a task priority weighting factor W i Based on the urgency of the task, the level of task dependency, and the complexity of resource requirements, a weighted scheduling priority evaluation function F is constructed. ij The evaluation function is defined as: F ij =W i ·T ij ; For all task nodes v i In all computing resource nodes r j The weighted scheduling priority evaluation F is calculated separately above. ij Values, sorted, and then the corresponding weighted scheduling priority evaluation F is selected. ij The smallest computing resource node, as task node v i The target deployment node; After allocating the current task node, update the status information of the computing resource node, including the current queuing time and task load. The above steps are iterated for all task nodes to be scheduled until all task nodes have completed the allocation of resource nodes, generating a complete mapping table between task nodes and computing resource nodes.

10. The low-code automated generation and deployment method for developing large-scale artificial intelligence models according to claim 2, characterized in that, S6 specifically includes: S61. Receive the mapping table between the low-code instruction set and the task nodes and computing resource nodes, logically group them according to the functional type and dependency information of the task nodes, and generate a deployment unit configuration list. S62. For each task node in the deployment unit configuration list, build a corresponding containerized deployment unit. The deployment unit encapsulates low-code instructions, runtime dependencies, version identifiers and task metadata information to form a unified deployment image structure. S63. Generate a scheduling control script for each containerized deployment unit. The scheduling control script includes the deployment node address, initialization command sequence, resource request parameters, and execution entry function. The execution entry function is generated by the top-level task flow definition in the low-code instruction set. S64. Based on the mapping table, the deployment engine is invoked to distribute each containerized deployment unit to its corresponding target computing resource node, and the execution of the scheduling control script is triggered by remote command invocation. S65. After deployment, monitor the container running status and task execution progress on each computing resource node, and collect running logs and performance indicators for subsequent operation control and optimization strategy input.

Images