Graph structure based machine learning pipeline generation and deployment method and system

Abstract

The application discloses a kind of machine learning Pipeline generation and deployment method and system based on graph structure, it is related to machine learning automatic modeling technical field.The method comprises: obtaining the machine learning flowchart designed by graphical interface of user, node in the flowchart indicates operation, edge indicates data stream;Each node in the flowchart is mapped to corresponding algorithm, and executable machine learning Pipeline is generated;The Pipeline is executed, and feature engineering, model training and evaluation are completed, and evaluation index is obtained;If the evaluation index meets preset threshold, then the Pipeline is deployed as model service.The application is used to solve the problems that node interface semantic conflict is difficult to automatically and efficiently adapt in the prior art, and model inference deployment lacks compilation-level optimization for heterogeneous hardware characteristics.

Description

Technical Field

[0001] This invention relates to the field of automated modeling technology in machine learning, and more specifically, to a method and system for generating and deploying machine learning pipelines based on graph structures. Background Technology

[0002] Machine learning pipelines, as the core carrier of Machine Learning Lifecycle Management (MLOps), achieve end-to-end automated modeling by linking independent steps such as data preprocessing, feature engineering, model training, and model evaluation. In the current computing environment, in pursuit of ultimate performance and energy efficiency, model training and inference tasks are increasingly running on heterogeneous computing devices such as CPUs and GPUs. How to efficiently build cross-platform, reusable machine learning pipelines that are adaptable to different hardware characteristics has become a key technical issue in lowering the threshold for AI implementation and improving model iteration efficiency.

[0003] Existing machine learning pipeline construction methods primarily rely on workflow orchestration tools (such as Kubeflow and Airflow) or graphical modeling platforms (such as Azure ML Designer). These technologies typically use directed acyclic graphs (DAGs) to define task flows, with users representing data flow by dragging and dropping nodes and connecting edges. In these solutions, the system is mainly responsible for task scheduling and containerized execution, treating each node as an independent black-box functional unit. Data files or memory objects are passed through standardized input / output interfaces, thereby reducing the complexity of manually writing glue code and achieving a certain degree of automation and visualization of the process.

[0004] However, existing graphical building tools still have significant shortcomings in handling heterogeneous hardware adaptation and deep semantic connections. First, they lack sufficient interface semantic verification capabilities and automatic adaptation mechanisms. Existing tools often struggle to perceive the specific shape or memory layout of tensors within nodes and their compatibility with downstream nodes, leading to frequent "interface semantic conflicts" (e.g., connecting NHWC format output to NCHW format input). Users must manually insert transpose or rewrite code, severely hindering development fluency. Second, they lack compile-level optimization for inference scenarios. Current solutions mostly directly package and deploy the trained model files without performing operator fusion or graph pruning based on the instruction set characteristics of the target heterogeneous devices (such as CPUs or specific GPUs). This results in a large amount of redundant computation and memory copying during the inference phase, failing to fully utilize hardware performance. Furthermore, maintaining consistency between the training and inference graphs is difficult. Manually removing training-specific nodes can easily cause "training-serving skew," affecting the prediction accuracy of online models. Summary of the Invention

[0005] To overcome the aforementioned deficiencies of the prior art, embodiments of the present invention provide a graph-based machine learning pipeline generation and deployment method, which constructs an algorithm signature library adapted to heterogeneous devices and uses data transformation directed graphs to search for minimum cost adaptation paths, and performs operator fusion optimization based on isomorphic matching, in order to solve the problems in the prior art where node interface semantic conflicts are difficult to automatically and efficiently adapt, and where model inference deployment lacks compiler-level optimization for heterogeneous hardware characteristics.

[0006] To achieve the above objectives, the present invention provides the following technical solution:

[0007] A graph-based machine learning pipeline generation and deployment method includes the following steps: obtaining a machine learning flowchart designed by a user through a graphical interface, where nodes represent operations and edges represent data flows; constructing an algorithm signature library adapted to the characteristics of heterogeneous computing devices, the algorithm signature library including input / output tensor shape constraints, symbolic dimension rules, and operator fusion modes for algorithms on different hardware backends; parsing the flowchart, mapping nodes to corresponding algorithms based on the algorithm signature library, dynamically constructing a data transformation directed graph for edges with interface semantic conflicts during the mapping process, and searching for the adaptation path with the minimum weighted cost in the transformation directed graph to generate an executable machine learning pipeline containing the optimal adaptation subgraph; executing the pipeline to complete feature engineering, model training, and evaluation, and obtaining evaluation metrics; if the evaluation metrics meet a preset threshold, performing graph-level optimization based on the inference scenario on the pipeline, specifically: identifying the feature engineering subgraph and the model inference subgraph, performing operator fusion operations based on isomorphic matching on continuous nodes in the subgraph according to the hardware instruction set of the target deployment environment, generating an inference-specific deployment package and publishing it as a model service.

[0008] In a preferred embodiment, the step of dynamically constructing a data transformation directed graph for edges with interface semantic conflicts, and searching for the adaptation path with the minimum weighted cost in the transformation directed graph, specifically includes: identifying the output interface attributes of the upstream node of the current edge. Input interface attributes with downstream nodes The differences in dimensional features between them are identified; an atomic transformation operator set capable of handling these differences is selected from a pre-defined adaptation component library; each atomic transformation operator is instantiated as a graph node; the legal data flow between operators is defined as directed edges; and a directed data transformation graph is constructed; a path cost function is defined. ,in To estimate the inference delay of the conversion operator, This is an estimated value for video memory usage. As a measure of data accuracy loss, As weighting coefficients; in the directed graph of the data transformation, with This is the initial state. Given the final state, the total distance is calculated using the shortest path search algorithm. Find the smallest sequence of transformation operators; insert the sequence of transformation operators as an adaptation subgraph into the corresponding edge of the original flowchart, and update the topology and interface description of the entire graph.

[0009] In a preferred embodiment, the step of constructing an algorithm signature library adapted to the characteristics of heterogeneous computing devices includes: establishing a multi-dimensional signature vector for each algorithm node in the algorithm signature library, wherein the vector includes: a semantic signature, used to describe the business type and field constraints of the input and output data; a tensor symbolic signature, using symbolic expressions to describe the dimensional transformation rules of the input and output tensors, used to support the determination of dynamic dimension broadcasting mechanisms and shape derivation; and a hardware affinity signature, used to record the computing power consumption profile of the algorithm under different backends of CPU and GPU and the supported operator fusion modes.

[0010] In a preferred embodiment, the step of performing isomorphic matching-based operator fusion on consecutive nodes within the subgraph includes: performing static analysis on the evaluated pipeline to construct an intermediate representation of the computation graph; performing a sliding window scan on the intermediate representation based on hardware affinity signatures in the algorithm signature library to perform subgraph isomorphic matching and identify consecutive operator sequences that conform to the target deployment hardware instruction set acceleration mode; replacing the consecutive operator sequences with a single fusion operator node and rewriting the memory allocation strategy to eliminate the data copy overhead of intermediate operators; and removing gradient calculation nodes, backpropagation paths, and auxiliary evaluation nodes that are only valid during the training phase to generate an immutable inference graph.

[0011] In a preferred embodiment, obtaining the machine learning flowchart designed by the user through a graphical interface includes intelligent error detection, with the following specific steps: performing a framework topology check on the flowchart to obtain a labeled flowchart and a first error list; performing static derivation of the full graph dimensions based on the labeled flowchart and the tensor symbolic signature in the algorithm signature library; if the derived dimensions are incompatible with the expected dimensions of downstream nodes and a connected path cannot be found in the data transformation directed graph, then recording the error location and type and generating a second error list; generating diagnostic results based on the first and second error lists and prompting the user to correct them.

[0012] In a preferred embodiment, the framework topology verification specifically involves: parsing the flowchart information to construct a directed graph structure model containing node attributes and edge relationships; performing connectivity analysis and directed acyclicity detection on the directed graph structure model to obtain topology consistency verification results; locating and marking subgraphs with loops or broken chains based on the verification results to generate a marked flowchart; calculating the in-degree and out-degree of each node in the marked flowchart, performing dependency analysis, and deriving the process execution sequence; verifying the process specifications based on the process execution sequence and preset node type rules, and if an anomaly is detected, recording the error type and generating a first error list.

[0013] In a preferred embodiment, the step of parsing the flowchart and mapping nodes to corresponding algorithms based on the algorithm signature library further includes: parsing the flowchart and extracting a list of node requirements; matching the list of node requirements with the algorithm signature library to obtain a node-algorithm candidate set; when a node type corresponds to multiple algorithm signatures, performing a weighted scoring and sorting on each candidate, wherein the scoring combines the input / output interface matching degree, hardware resource consumption estimation, and the inner product of a preset business target vector; determining the target algorithm based on the sorting result, and generating a node-algorithm mapping table.

[0014] In a preferred embodiment, generating an executable machine learning pipeline containing an optimally adapted subgraph specifically involves: performing topological sorting based on the updated graph structure to generate an execution sequence; binding parameter templates and default hyperparameters to each node to form a parameter table and a component list; generating an intermediate representation of the executable pipeline, the intermediate representation including a node-algorithm mapping table, input / output interfaces, execution sequence, parameter table, component list, and resource binding information; and converting the intermediate representation into a pipeline description to obtain an executable machine learning pipeline.

[0015] In a preferred embodiment, the publishing as a model service specifically involves: generating a service interface definition, the definition including an inference-optimized description of the input and output tensor shapes; packaging the model files, statistics files, and dependent components into an immutable deployment package with a version number; and publishing the model service API endpoint according to the service interface definition.

[0016] This invention provides a graph-based machine learning pipeline generation and deployment system, comprising: a process acquisition module for acquiring a machine learning flowchart designed by a user through a graphical interface, wherein nodes in the flowchart represent operations and edges represent data flows; a pipeline generation module for constructing an algorithm signature library adapted to the characteristics of heterogeneous computing devices, wherein the algorithm signature library includes input / output tensor shape constraints, symbolic dimension rules, and operator fusion modes for algorithms on different hardware backends; parsing the flowchart, mapping nodes to corresponding algorithms based on the algorithm signature library, and dynamically constructing a data transformation directed graph for edges with interface semantic conflicts during the mapping process, and in the... The system transforms the directed graph to search for the adaptation path with the minimum weighted cost, generating an executable machine learning pipeline containing the optimal adaptation subgraph. A pipeline evaluation module executes the pipeline, completing feature engineering, model training, and evaluation to obtain evaluation metrics. A pipeline deployment module performs graph-level optimization based on the inference scenario if the evaluation metrics meet a preset threshold. Specifically, it identifies the feature engineering subgraph and the model inference subgraph, performs isomorphic matching-based operator fusion operations on continuous nodes within the subgraph according to the hardware instruction set of the target deployment environment, generates an inference-specific deployment package, and publishes it as a model service.

[0017] The technical effects and advantages of the graph-based machine learning pipeline generation and deployment method of this invention are as follows:

[0018] This invention achieves automated optimal adaptation of semantic conflicts between nodes in the process by constructing an algorithm signature library adapted to heterogeneous computing devices and combining it with a dynamically constructed directed graph of data transformation and a minimum cost path search mechanism. This effectively solves the problems of low efficiency and difficulty in balancing performance when manually configuring transformation operators. Furthermore, this invention automatically eliminates redundant computation and memory overhead in the inference stage by performing isomorphic matching-based operator fusion optimization according to the hardware instruction set of the target deployment environment, thereby generating a high-performance, low-latency deployment package specifically for inference. Attached Figure Description

[0019] Figure 1 This is a schematic diagram of the graph-based machine learning pipeline generation and deployment method provided in an embodiment of the present invention.

[0020] Figure 2 This is a schematic diagram illustrating the construction of a directed graph and the search for the optimal adaptation path when there is an interface semantic conflict, as provided in an embodiment of the present invention.

[0021] Figure 3 This is a block diagram of the graph-based machine learning pipeline generation and deployment system provided in an embodiment of the present invention. Detailed Implementation

[0022] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of the present invention.

[0023] Example 1, Figure 1 This invention presents a graph-based machine learning pipeline generation and deployment method, comprising the following steps:

[0024] S1. Obtain the machine learning flowchart designed by the user through a graphical interface. In the flowchart, nodes represent operations and edges represent data flows.

[0025] In this embodiment, the specific steps of S1 are as follows:

[0026] S101, Perform a framework topology check on the flowchart to obtain a marked flowchart and a first error list, specifically:

[0027] (1) Parse the flowchart information, construct a directed graph structure model, and obtain a graph structure description file containing node attributes and edge relationships:

[0028] After the user completes the graphical drag and drop and connection, the system serializes the node and edge information generated by the front end into structured data, parses the node set and edge set as well as node / port attributes, and constructs a directed graph structure model based on this.

[0029] The directed graph structure model is persisted using a graph structure description file. This file not only saves the visual structure but also the semantic attributes (including node type, port signature, expected data dimension, etc.) used for subsequent verification and generation, thereby transforming the "interface graph" into a "verifiable and compileable" intermediate representation. Specifically:

[0030] Parse the flowchart information into a directed graph. Where V is the set of nodes and E is the set of directed edges, Map node attributes (including node identifier id, node type type, input / output port set ports, port expected dimension / type signature sig, etc.). Mapping edge attributes (including start / end port, data dimension description dim, field schema, etc.);

[0031] The graph structure description file can be represented in JSON or an equivalent structured format, containing adjacency information and an attribute dictionary, so that subsequent algorithms can directly read and compute it.

[0032] (2) Perform connectivity analysis and directed acyclicity detection on the graph structure description file to obtain the topology consistency verification results:

[0033] To perform connectivity analysis and directed acyclicity detection, the system first constructs an adjacency matrix or adjacency list representation based on the edge set. Taking the adjacency matrix M as an example, let |V|=n, for any numbered nodes... If an edge exists Then set M[i,j]=1, otherwise set it to 0;

[0034] Based on this, the in-degree and out-degree of each node are defined for dependency analysis and topological sorting. The formula for calculating the in-degree / out-degree is as follows:

[0035] node in-degree: ,

[0036] node Out-degree: ,

[0037] Connectivity analysis uses weak connectivity and source-to-sink reachability determination. For any data source type node (defined as a node that only outputs and does not receive in the preset node type rules) and any output type node (a node that only receives and does not output), if there is no path from any data source to any output, it is judged as a broken link.

[0038] The directed acyclicity detection is based on the topological sorting criterion. If a sequence covering all nodes can be obtained by continuously selecting nodes with an in-degree of zero and deleting their outgoing edges, then the graph is acyclic; otherwise, at least one directed cycle exists. The necessary and sufficient condition for the topological determination is that "a topological sequence of length n can be generated". The image shows a DAG.

[0039] (3) Based on the verification results, locate and mark the subgraphs containing loops or broken chains, and generate a marking flowchart:

[0040] After obtaining connectivity and acyclicity determination, the system attaches loop nodes, broken chain edges, or isolated subgraphs to the corresponding nodes or edges in the graph structure description file with annotation fields (e.g., adding attributes tags={cycle, break, isolated} and location information to nodes / edges), and simultaneously renders them to the front-end interface to form a labeled flowchart.

[0041] The marked flowchart is not a new graph entity, but a visual representation of a graph structure description file with error / alarm annotations on the interface, used to support subsequent dependency analysis and prompts.

[0042] (4) Using the node in-degree and out-degree calculation method, dependency analysis is performed on each node in the marked flowchart to obtain the process execution sequence:

[0043] Dependency analysis relies on in-degree / out-degree and reachability information, where in-degree represents previous dependencies and out-degree represents subsequent dependencies. A topological sort is used to generate the process execution sequence.

[0044] First, add all nodes with an in-degree of zero to the candidate set. Then, take out the nodes in order and add them to the execution sequence. At the same time, "remove" their out edges and update the in-degree of adjacent nodes. Repeat this process until the candidate set is empty.

[0045] If the sequence length is less than the total number of nodes, the topological sorting has been blocked by the subgraph marked as a loop in the previous step. In this case, a complete execution sequence is not generated, and only a partial sequence within the reachable range is output.

[0046] The process execution sequence is denoted as This is the execution constraint for subsequent mapping and compilation.

[0047] (5) Based on the process execution sequence and preset node type rules, determine whether the process conforms to the specifications. If an anomaly is detected, record the error type and generate a first error list:

[0048] Preset node type rules are used to determine whether a process conforms to specifications, and their core components include:

[0049] Data source node satisfies The output node satisfies Processing intermediate nodes satisfies The number of fan-out nodes in a branch node does not exceed the set upper limit. The number of fan-in nodes at the merging nodes does not exceed the set upper limit. And all training paths must have at least one reachable path from the data source through the feature processing node to the learner node and then to the evaluation / output node;

[0050] Based on the above rules and process execution sequence, consistency judgment is performed on each node and edge. If a violation is detected, a first error list is formed. The list includes error number, error type (loop, broken chain, isolated subgraph, boundary violation, fan-out / fan-in violation, etc.), location information (node ​​ID / edge ID and path fragment), severity level (blocking / warning), and suggestions.

[0051] S102, based on the marked flowchart, by comparing the matching relationship between the data dimensions transmitted on each edge and the expected dimensions of adjacent nodes, a second error list is obtained:

[0052] After completing the topology annotation, the data dimensions are validated based on the annotation flowchart:

[0053] The actual dimension carried by each edge is compared with the expected input dimension of its terminal node. If the node is a one-in-one-out type, the edge dimension must be compatible with the node's expected dimension (equal length or broadcastable). If the node has multiple in-degrees, dimension conservation is performed according to the merging strategy. For example, according to the splicing strategy, "the output dimension equals the sum of the dimensions of each incoming edge" should be satisfied; according to the summation / averaging strategy, "the dimensions of each incoming edge are equal" should be satisfied. The calculation formulas for the three typical dimension determinations are as follows:

[0054] Output dimensions of splicing merge nodes: ;

[0055] Dimensional constraints for summation / average type merging nodes: ;

[0056] Dimensional compatibility of one-in-one-out transformation nodes Node signature must be satisfied The specified mapping relationship (e.g., standardization to keep dimensions unchanged, PCA will) Mapped to the set number of principal components );in This indicates the feature dimension carried by edge e. Let v represent the set of incoming edges of node v, where all dimension variables are positive integers;

[0057] To facilitate auditing, the system generates a dimension mapping table, recording the actual dimension of each edge, the expected dimension of each port, and the dimension derivation results of the merging / branching nodes. Based on this, a second error list is formed, which includes error number, error type (dimension inequality, inability to concatenate, non-broadcastable, missing field, type incompatibility, etc.), location information (in / out port and edge ID), actual value and expected value pair, severity level, and remediation suggestions (e.g., inserting dimension reshaping or encoding nodes).

[0058] S103, Generate diagnostic results based on the first and second error lists and prompt the user to correct them:

[0059] The system generates diagnostic results based on the first and second error lists, maps the error types and location information to interface highlights and message prompts, and prevents the system from entering the mapping and compilation stage when a blocking level error exists.

[0060] When only warning-level issues exist, the prompt can be retained and the process can continue, ensuring that the user completes the correction on the interface and then triggers the validation again until both lists are empty or only acceptable warnings remain.

[0061] In summary, this step transforms the graphical process into a formalized intermediate representation of a directed graph. By combining topological consistency determination based on in / out degree and adjacency relationships with dimension conservation verification based on node signatures, it can identify key defects that lead to execution failures, such as loops, broken links, and dimension mismatches, in advance. It outputs a standardized process with annotations and establishes a traceable error list, thereby achieving the technical effects of reducing the failure rate in subsequent mapping and deployment stages, ensuring consistency between training and inference, and shortening the iteration cycle.

[0062] S2, map each node in the flowchart to the corresponding algorithm to generate an executable machine learning pipeline.

[0063] In this embodiment, the specific steps of S2 are as follows:

[0064] The algorithm for mapping each node in the flowchart to its corresponding node is as follows:

[0065] S201, parse the marked flowchart, extract node types, upstream and downstream input / output interfaces, and target task information to form a node requirement list:

[0066] The system first parses the functional attributes and upstream / downstream interface semantics of each node based on the graph structure description file of the marked flowchart, extracting node type, input / output interface signature, and target task information to form a node requirement list, specifically:

[0067] Each node in the flowchart is represented by a unique identifier v, and its set of input interfaces is denoted as v. The set of output interfaces is denoted as Each interface contains a set of fields. With dimension vector (Each component is a positive integer, representing the feature length or tensor shape), node functional type The target task label T is configured by the user in the interface or inferred from the type of the endpoint node, and the system constructs the node requirement entries accordingly. This includes: parsing node metadata, standardizing interface fields and dimension descriptions, binding node function types and task tags, and summarizing them into a node requirement list. .

[0068] S202, Construct an algorithm signature library, which includes input / output data patterns, dimension and type constraints, required component types, and resource requirements:

[0069] To achieve a verifiable match between "requirements" and "algorithm implementation," the system builds an algorithm signature library. Each algorithm signature element Represented as an extended vector, it specifically contains the following three parts of signature information:

[0070] 1) Semantic signature: describes the business type (such as "image features" or "text embedding") and field constraints of input and output data, and is used for type verification at the logical level.

[0071] 2) Tensor Symbolic Signature: This uses symbolic expressions to describe the dimensionality transformation rules of input and output tensors. For example, for convolution operations, the input shape is defined as... The output shape is defined as ,in For dynamic batch dimension, and These represent the number of input and output channels, respectively. and The height and width of the input feature map are given. These are the algorithm parameters. This enables the system to support dynamic dimensional broadcasting mechanisms for determination and shape derivation, rather than just fixed numerical comparisons.

[0072] 3) Hardware affinity signature: Records the characteristics of the algorithm under different heterogeneous computing devices such as CPU and GPU. Specifically, it includes: (a) computing power consumption profile, that is, based on the peak computing power and bandwidth characteristics of the device, establishing an estimation model of inference latency and memory usage under different input scales; (b) supported operator fusion pattern, that is, based on the instruction set architecture of the device, declaring that the "convolution" operator can be merged with the downstream "BatchNorm" and "ReLU" operators into a "Conv2d_BN_Relu" fusion operator.

[0073] The signature library is built using a combination of offline registration and online expansion: baseline signatures are generated for built-in algorithms based on development documentation, and operator fusion modes and performance profiles for common heterogeneous computing devices (such as NVIDIA GPUs and Intel CPUs) are pre-configured; user-defined components are registered with their I / O interfaces, symbolic dimension rules, and resource profiles according to a unified template; all signatures are entered into the library after pattern checking and deduplication, specifically by regularizing the field set, tensor symbolic expression, and fusion mode, and generating hash fingerprints to ensure uniqueness.

[0074] S203, Match the node requirement list with the algorithm signature library to obtain a node-algorithm candidate set. When a node type corresponds to multiple algorithm signatures, perform compatibility scoring and sorting on each candidate. The compatibility score is determined based on the input / output interface matching degree and the compliance with resource and latency constraints.

[0075] The system employs a two-stage strategy of "hard constraint filtering + compatibility scoring and ranking" to select a candidate set for each node from the signature database and determine the target algorithm. First, for each entry... ,exist Signatures that meet the functional category matching and whose I / O interface specifications are semantically compatible with the node interface are selected to form a node-algorithm candidate set. Semantic compatibility is determined based on the intersection and union relationships and dimensional compatibility relationships of the field sets. The field set matching degree is measured using the Jaccard coefficient, and the formula for calculating the field matching degree is as follows:

[0076] ,

[0077] in Indicates upstream node Output field set, Indicates the current node The expected set of input fields; dimensional compatibility is determined by the function. Judgment, among which upstream node The actual output dimension vector, For the current node The expected input dimension vector, Candidate Algorithms The interface signature specification. This function takes a value of 1 to indicate equal length or meets the broadcast / concatenation conditions allowed by the signature, and a value of 0 to indicate incompatibility. Specifically:

[0078] If the signature statement "keeps dimensions unchanged", then it requires If "splicing along axis" is declared, then all axes except the splicing axis must be equal and the output dimension must be equal to the sum of the dimensions of the input edges. The formula is:

[0079] ,

[0080] In the formula, Indicates the index of the dimension axis. Represents a node The set of all incoming edges, Indicates incoming edges The data transmitted up in the first The length of the dimension. After passing through the "hard" filtering of semantic and dimensional compatibility mentioned above, the process enters the "soft" sorting stage;

[0081] To make a selection that conforms to the context and SLA (Service Level Agreement) among multiple available candidates, the system... Compatibility score for intrinsic element calculation The score is composed of four weighted components: interface matching, type matching, dimensional compatibility, and SLA compliance. The formula is as follows:

[0082] ,

[0083] in This refers to system or project-level weights; The field matching degree calculated above; The dimensional compatibility determination result obtained from the aforementioned calculation; Determine if the data type (numerical / categorical / time-series, etc.) meets the requirements; For the algorithm The resource demand vector under the standard sample, where This indicates the number of CPU logical cores or computing power utilization required for the algorithm to run. Indicates the required system memory (RAM) size. This indicates the required GPU memory size or the number of graphics computing units; Let be the resource budget constraint vector for the node in the current deployment environment, where This indicates the maximum number of CPU cores that the environment can allocate to this node. Indicates the maximum available system memory. Indicates the maximum available GPU memory or computing resources; For the algorithm The estimated inference delay; This sets the resource budget and latency limit for the node in its current operating environment. SLA compliance is defined as follows:

[0084] ,

[0085] when If it is not in compliance with soft constraints, it will be downgraded to the lowest priority.

[0086] It should be noted that the SLA compliance measure is whether the model meets the predetermined resource and latency requirements in actual operation.

[0087] S204. If the compatibility scores are the same or there is a preset business objective, the candidates are reordered according to the priority strategy of the objective task, and the target algorithm is determined:

[0088] If there are ties in compatibility scores or the project declares preset business objectives (such as priority recall, priority explainability, priority low latency, etc.), the system will reorder the candidates according to the target task priority strategy, specifically by introducing a target vector. ( (Weights for recall, interpretability, and latency, respectively) and algorithm feature vector. ( These represent the algorithm's recall and interpretability in the task, respectively. Interpretability is typically measured using some metric, such as LIME or SHAP. The scores are then adjusted as follows:

[0089] ,

[0090] in This is the strategy strength coefficient. This represents the inner product; when there are "must" properties (e.g., must output probability, must be differentiable), the constraint indicator function is set to zero for those that are not satisfied. The final choice makes... The largest signature is used as the target algorithm, specifically: Calculate The first signature is determined by descending order of S' and the selection criteria are recorded.

[0091] S205: For nodes that cannot match the algorithm signature due to not meeting hard constraints such as input / output interfaces, dimensions, or types, record the error location and error type and add them to a second error list to block the generation of the executable pipeline and prompt the user to correct it.

[0092] If a certain entry If the candidate set is empty after hard filtering, meaning there is no signature that satisfies the interface semantics and dimension compatibility, the system will register the node in the second error list to block pipeline generation and prompt for correction. Specifically, the list records the node identifier, missing capability category (field mismatch, dimension incompatibility, type conflict), the difference between the expected interface specification and the actual interface specification, and the suggested repair actions (such as changing the node type or inserting encoding / reshaping the node upstream) to ensure that the error can be located and reproduced.

[0093] S206, Perform upstream and downstream interface consistency verification on the node-algorithm candidate set. For edges with interface semantic conflicts, dynamically construct a data transformation directed graph, and search for the adaptation path with the minimum weighted cost in the transformation directed graph to generate the optimal adaptation subgraph:

[0094] When the system detects the output interface attribute of the upstream node Input interface attributes with downstream nodes When inconsistencies occur (e.g., mismatched dimensions and shapes, incompatible data layout formats such as NHWC and NCHW), instead of being limited to inserting a single adapting node, the following graph search algorithm is executed:

[0095] 1) Identify differential features: Calculate and Difference vectors in dimension (Shape), data type (Dtype), and memory layout (Layout).

[0096] 2) Construct a directed graph for data transformation: Select all atomic transformation operators (such as Reshape, Transpose, Cast, Flatten, Unsqueeze, etc.) that can handle some or all differences in features from the pre-defined adaptation component library. Instantiate each atomic transformation operator as a graph node, and define the legal data flow directions between operators that meet the input-output constraints as directed edges, thereby constructing a local directed graph for data transformation.

[0097] 3) Define the path cost function: Define the cost weight for each edge or node in the graph. .in, To estimate the inference latency of the conversion operator on the target hardware; Estimated video memory / memory usage for operations (e.g., copy operations are costly, view operations are inexpensive). This is a measure of data precision loss (for example, converting float32 to int8 will result in precision loss). These are preset weighting coefficients.

[0098] 4) Optimal path search: Starting from the initial state, with Given the endpoint state, search the total number of states in the transition directed graph using Dijkstra's algorithm or A* algorithm. The shortest path. For example, the shape... Convert to The system may find two paths: "Transpose -> Reshape" or "Reshape (if memory is contiguous)". The system will choose the operator sequence corresponding to the path with lower cost.

[0099] 5) Generate adaptation subgraph: Insert the optimal sequence of transformation operators found as an adaptation subgraph into the corresponding connection point of the original flowchart, and update the topology and interface description of the entire graph.

[0100] like Figure 2 The image shows a specific example of constructing a directed graph for data transformation and searching for the optimal path in response to interface semantic conflicts in an embodiment of the present invention.

[0101] Assume the tensor output by upstream node A has the following shape: (NHWC format), and the expected input tensor shape of downstream node B is... (That is, the channels are placed first, and then the spatial dimensions are flattened). After the system identifies the dimensional feature mismatch, it instantiates atomic transformation operators from the adaptation component library and constructs a transformation graph.

[0102] The figure shows two potential connected paths found by the system:

[0103] Path 1: First, the 'Transpose' operator is executed to shift the channel dimension to the second position (NHWC -> NCHW). At this point, physical data transfer occurs in memory, and the calculated cost is... The initial cost is relatively high (example value is 15); then the 'Flatten' operator is executed to flatten the last two dimensions, which only modifies the metadata and has a lower cost (example value is 2). The total cost of path 1 is 17.

[0104] Path 2: First, attempt to execute the 'Reshape' operator to merge spatial dimensions. The cost is extremely low (example value is 2); however, a large matrix 'Transpose' operation must then be performed to match the target shape. This results in extremely high latency costs (example value is 20). The total cost of path 2 is 22.

[0105] After comparing the results using Dijkstra's shortest path algorithm, the system determines that 17 < 22, and therefore automatically selects path 1 as the optimal adaptation scheme. The system then generates an operator sequence containing two nodes, 'Transpose' and 'Flatten', and inserts it as an adaptation subgraph between node A and node B, thereby optimizing inference performance while ensuring logical correctness.

[0106] Furthermore, the generation of the executable machine learning pipeline specifically includes:

[0107] S207, Perform topological sorting based on the updated graph structure to generate the execution sequence:

[0108] After obtaining a consistent graph structure, the system enters the Pipeline generation phase. First, a topological sort is performed on the updated graph to generate an execution sequence. The in-degree iterative elimination criterion is adopted. If there are nodes with non-zero in-degree that cannot be eliminated, the process will fall back to the aforementioned error list to indicate that the loop has not been cleared.

[0109] S208 binds parameter templates and default hyperparameters to each node, forming a parameter table and component list:

[0110] Each node is bound to a parameter template and default hyperparameters, forming a parameter table and component list. The parameter templates are derived from the default configuration of the algorithm signature and supplemented with dataset metadata (such as the number of features and the cardinality of categories). The default hyperparameters are initialized with the security domain values ​​registered in the signature. Specifically, for each node... Generate parameter set With dependent component collection Then summarize them into a global parameter table. With component list .

[0111] S209, Generate an intermediate representation of the executable pipeline, the intermediate representation including a node-algorithm mapping table, input / output interfaces, execution sequence, parameter table, component list, and resource binding information:

[0112] To achieve deterministic execution across engines and environments, the system generates an executable intermediate representation (IR). The IR includes node-algorithm mappings, I / O interfaces, execution sequences, parameter tables, component lists, and resource binding information. etc.; IR is represented using JSON or an equivalent DSL, and carries complete artifact references and version fingerprints for subsequent code generation and container orchestration, specifically generated for each node. Quadruple and The sequence is concatenated, where op represents the abstract operator type or functional semantics of the node, used to identify logical operations; impl_id represents the unique identifier of the specific algorithm implementation mapped to, used to lock the specific code implementation and hardware version.

[0113] S210, the intermediate representation is converted into a pipeline description to obtain an executable machine learning pipeline:

[0114] The system converts the IR (Input / Output Query) into a pipeline description (such as an operator DSL, scheduling graph, or container workflow specification) that the target execution engine can recognize. This process translates nodes into engine operators while preserving their order, compiles parameter tables into runtime configurations, and parses component manifests into dependency loading instructions. Finally, the system calculates the hash value of the generated file. This serves as the unique fingerprint for that version.

[0115] This step establishes a formal contract of "node requirements - algorithm signature," employs a selection mechanism of "hard constraint filtering + compatibility scoring + task priority reordering," combines consistency repair through "minimum cost adaptation" with a deterministic compilation chain of "intermediate representation -> execution description," first parses and standardizes node requirements, then selects target implementations using scoring and strategies, inserts adapting nodes and updates the graph structure when interface specification conflicts are encountered, and finally generates IR by binding parameters and resources with topological order and completes engine-level transformation. This achieves the technical effect of stably generating executable pipelines from a visual workflow without relying on manual coding. This method effectively reduces the risk of runtime failures due to interface / dimensional mismatches, improves the consistency and reproducibility of pipeline generation, and provides verifiable input for subsequent evaluation, gating, and deployment.

[0116] S3, execute the Pipeline to complete feature engineering, model training and evaluation, and obtain evaluation metrics.

[0117] In this embodiment, the specific steps of S3 are as follows:

[0118] The system will execute feature engineering nodes based on the generated pipeline. These feature engineering nodes will perform appropriate preprocessing operations on the input data, such as handling missing values, standardization, normalization, feature selection, or generating new features. Specifically, the feature engineering nodes will extract features from the original dataset D. By using different processing algorithms, such as mean padding and Z-score normalization, the data is transformed into a format suitable for model training, generating a processed feature set. For example, for standardized operations, the following formula is used:

[0119] ,

[0120] in and These represent the mean and standard deviation of the feature columns, respectively. Feature engineering ensures the normalization of the model input, providing optimized input for subsequent model training.

[0121] The training nodes in the pipeline will use the processed data. Model training is then performed. The training phase relies on a previously selected algorithm, which can be a different type of machine learning algorithm (such as logistic regression, decision trees, SVM, etc.) depending on the task type. The specific training process involves adjusting the model parameters using optimization algorithms (such as gradient descent) to minimize the loss function. The formula is as follows:

[0122] ,

[0123] in For model parameters, For loss function, These are the optimal model parameters that minimize the loss function, obtained through training iterations. During model training, the system records the loss value for each training round and evaluates the model's performance using cross-validation or other validation methods to avoid overfitting or underfitting.

[0124] After training is complete, the pipeline enters the model evaluation phase, where evaluation nodes assess the performance of the trained model. The evaluation metrics will vary depending on the task. For example, classification tasks might use accuracy, precision, recall, or F1 score, while regression tasks might use mean squared error (MSE), R², etc. For classification tasks, the formula for calculating accuracy is as follows:

[0125] ,

[0126] TP, TN, FP, and FN represent true positives, true negatives, false positives, and false negatives, respectively. Based on preset evaluation criteria (such as accuracy thresholds and F1 scores), the system generates an evaluation report containing the specific values ​​for each evaluation indicator.

[0127] Finally, the system determines whether the preset standards are met based on the evaluation results. If the evaluation indicators meet the requirements, the Pipeline is marked as successfully generated and can be further deployed as an online prediction service; if the evaluation fails to meet the standards, the user is prompted to adjust the data processing or model configuration and re-execute the Pipeline.

[0128] This step, through preprocessing, training, and evaluation processes, combined with the rational design of feature engineering and the optimization of model training, ensures the generation of a high-quality machine learning model. An accurate evaluation mechanism ensures the model achieves the expected results and provides stable and reliable support for subsequent deployment phases.

[0129] S4. If the evaluation index meets the preset threshold, then the Pipeline is deployed as a model service.

[0130] In this embodiment, the specific steps of S4 are as follows:

[0131] S401 performs graph-level optimization based on the inference scenario on the evaluated executable machine learning pipeline. Specifically, it identifies the feature engineering subgraph and the model inference subgraph, and performs isomorphic matching-based operator fusion operations on continuous nodes within the subgraph according to the hardware instruction set of the target deployment environment.

[0132] The system not only removes gradient calculation nodes, backpropagation paths, and auxiliary evaluation nodes (such as DropOut and Loss calculation) that are only valid during the training phase, but also further optimizes the remaining inference graph at the compilation level. The specific steps are as follows:

[0133] 1) Constructing Intermediate Representation (IR): Perform static analysis on the evaluated pipeline and convert it into an intermediate representation of the computation graph to obtain a graph description decoupled from the specific framework.

[0134] 2) Subgraph Isomorphic Matching: Based on hardware affinity signatures defined in the algorithm signature library, a sliding window scan is performed on the IR. The system performs isomorphic matching between the operator substructures in the graph and the operator fusion patterns in the signature library. For example, if a consecutive "Convolution"->"BatchNorm"->"ReLU" structure is found in the graph, and the target hardware (such as a GPU) supports this fusion instruction, the system marks the consecutive operator sequence as a "candidate group to be fused".

[0135] 3) Operator Fusion: Replace the marked consecutive operator sequence with a single fused operator node (Fused Operator). For example, replace the three operators above with a single Fused_Conv2d_BN_Relu operator. This step can significantly reduce the number of kernel launches and rewrite the memory allocation strategy to eliminate the data copy overhead of intermediate operators (such as the output of BatchNorm), thereby greatly improving inference speed and reducing GPU memory usage.

[0136] 4) Generate an immutable inference graph: After completing all possible fusions, lock the graph structure and generate the final inference-specific graph for deployment.

[0137] S402, Generate a service interface definition, the definition containing an inference-optimized description of the input / output tensor shapes:

[0138] The service interface definition describes how to provide model inference services to external systems via API. The interface definition includes information such as input and output data formats, data types, and field constraints. Specifically, the system generates standardized API interface specifications based on the input and output interface information of each node in the pipeline. These API specifications include the format of the requested data (e.g., JSON, Protobuf), and constraints such as the type, value range, and data dimensions of each field. For each interface, the system generates corresponding input and output data descriptions based on the node's requirements and the target task type, and formats them uniformly. For example, if the model is a binary classification problem, the interface request data includes two input fields: a feature vector and a label; the response data includes information such as the predicted class and probability value. This generated interface definition conforms to RESTful specifications or other applicable API specifications to ensure seamless integration with external applications.

[0139] Furthermore, the system packages model files, statistical files, and dependent components into a versioned and immutable deployment package. This deployment package is used to deploy and run machine learning model services in a production environment, ensuring model version control and traceability. Specifically, model files (such as weight files obtained from training), statistical files (such as the mean, standard deviation, and other statistics during training), and other dependent components (such as external libraries and model-related configuration files) are packaged into an executable file or container image. This packaging process also generates a unique version number for each file to manage different versions of the model. During packaging, the system performs integrity checks to ensure all files have not been tampered with and uses encryption algorithms to generate hash values ​​to ensure file immutability.

[0140] S403, Publish the model service API endpoint according to the service interface definition:

[0141] Based on the service interface definition, the system will publish the model service API endpoint. The process of publishing the API endpoint includes configuring the server's network access path according to the interface definition and exposing the model service to external applications for invocation. Specifically, the system configures the API endpoint according to the generated interface definition and deploys it to a specified server or cloud environment. In a cloud environment, settings such as API gateway, load balancer, and port mapping need to be configured to ensure that the API endpoint can stably and quickly respond to external requests.

[0142] This step, through a holistic process of inference optimization, interface definition generation, deployment package packaging, and API endpoint publishing, ensures the stability and reusability of the machine learning model. Through this series of optimizations, the system ensures efficient and accurate inference, and that the model can be successfully deployed as an exposed API service. This approach effectively automates the process from model training to deployment, while also guaranteeing model version management and service scalability.

[0143] Furthermore, this embodiment introduces an optimal path search mechanism for the directed graph of data transformation, which not only solves the complex interface mismatch problem but also automatically finds the transformation scheme with the lowest latency and memory cost, avoiding performance bottlenecks that may be introduced by manual adaptation. Simultaneously, the hardware affinity-based operator fusion technology ensures that the generated deployment package is no longer a simple model file but a specially compiled and optimized inference graph, effectively improving the response speed of the model service in a production environment.

[0144] Example 2, Figure 3 A graph-based machine learning pipeline generation and deployment system is presented, including:

[0145] The process acquisition module is used to acquire the machine learning process diagram designed by the user through a graphical interface. In the process diagram, nodes represent operations and edges represent data flows.

[0146] The Pipeline generation module is used to construct an algorithm signature library adapted to the characteristics of heterogeneous computing devices. The algorithm signature library includes input / output tensor shape constraints, symbolic dimension rules, and operator fusion modes for algorithms on different hardware backends. The module parses the flowchart and maps nodes to corresponding algorithms based on the algorithm signature library. During the mapping process, for edges with interface semantic conflicts, a data transformation directed graph is dynamically constructed, and the adaptation path with the minimum weighted cost is searched in the transformation directed graph to generate an executable machine learning pipeline containing the optimal adaptation subgraph.

[0147] The Pipeline evaluation module is used to execute the Pipeline, complete feature engineering, model training and evaluation, and obtain evaluation metrics.

[0148] The Pipeline deployment module is used to perform graph-level optimization based on the inference scenario on the Pipeline if the evaluation index meets the preset threshold. Specifically, it identifies the feature engineering subgraph and the model inference subgraph, performs operator fusion operation based on isomorphic matching on the continuous nodes in the subgraph according to the hardware instruction set of the target deployment environment, generates a deployment package for inference and publishes it as a model service.

[0149] The above formulas are all dimensionless calculations. The formulas are derived from software simulations based on a large amount of collected data to obtain the most recent real-world results. The preset parameters in the formulas are set by those skilled in the art according to the actual situation.

[0150] The above embodiments can be implemented, in whole or in part, by software, hardware, firmware, or any other combination thereof. When implemented using software, the above embodiments can be implemented, in whole or in part, in the form of a computer program product.

[0151] Those skilled in the art will recognize that the modules and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0152] In addition, the functional modules in the various embodiments of this application can be integrated into one processing module, or each module can exist physically separately, or two or more modules can be integrated into one module.

[0153] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

[0154] In conclusion, the above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A method for generating and deploying machine learning pipelines based on graph structures, characterized in that, Includes the following steps: Obtain a machine learning flowchart and construct an algorithm signature library adapted to the characteristics of heterogeneous computing devices; in the machine learning flowchart, nodes represent operations and edges represent data flows. The flowchart is analyzed, and algorithm nodes are mapped to specific algorithm signatures based on a signature library. For edges with interface semantic conflicts, a directed data transformation graph is constructed and the minimum-cost adaptation path is searched to generate an executable pipeline containing the optimal adaptation subgraph. Specifically, constructing the directed data transformation graph and searching for the minimum-cost adaptation path for edges with interface semantic conflicts includes: identifying the difference dimension features between the output interface attributes of upstream nodes and the input interface attributes of downstream nodes in the flowchart; selecting atomic transformation operators capable of handling the difference dimension features from a pre-defined adaptation component library, and constructing a directed data transformation graph using these operators as nodes and legitimate data flow directions as directed edges; searching for the sequence of transformation operators with the minimum total cost in the directed data transformation graph based on the path cost function, starting from the output interface attribute and ending at the input interface attribute; inserting the sequence of transformation operators as an adaptation subgraph at the corresponding edge of the original flowchart, and updating the topology of the flowchart. Execute the pipeline to complete training evaluation; If the evaluation is successful, identify the feature engineering and model inference subgraphs, perform isomorphic matching-based operator fusion optimization on the continuous nodes in the subgraphs, generate a deployment package, and publish the service.

2. The method for generating and deploying a machine learning pipeline based on a graph structure according to claim 1, characterized in that, The construction of an algorithm signature library adapted to the characteristics of heterogeneous computing devices includes: For each algorithm node in the algorithm signature library, a multidimensional signature vector is created, the vector containing: Semantic signatures are used to describe the business type and field constraints of input and output data; Tensor symbolic signatures use symbolic expressions to describe the dimensional transformation rules of input and output tensors, which are used to support the determination of dynamic dimension broadcasting mechanisms and shape derivation. Hardware affinity signatures are used to record the computational power consumption profile of the algorithm under different backends of CPU and GPU and the supported operator fusion modes.

3. The method for generating and deploying a machine learning pipeline based on a graph structure according to claim 2, characterized in that, Perform isomorphic matching-based operator fusion optimization on consecutive nodes in the subgraph, including: Static analysis is performed on the evaluated pipelines to construct intermediate representations of the computational graph; Based on the hardware affinity signatures in the algorithm signature library, a sliding window scan is performed on the intermediate representation to perform subgraph isomorphic matching and identify a continuous operator sequence that conforms to the target deployment hardware instruction set acceleration mode. The continuous operator sequence is replaced with a single fusion operator node, and the memory allocation strategy is rewritten to eliminate data copy overhead. Remove nodes and paths that are only valid during the training phase to generate an immutable inference graph.

4. The method for generating and deploying a machine learning pipeline based on a graph structure according to claim 2, characterized in that, The process of obtaining the machine learning flowchart includes intelligent error detection, and the specific steps include: Perform a framework topology check on the flowchart to obtain a marked flowchart and a first error list; Based on the marked flowchart and the tensor symbolic signatures in the algorithm signature library, perform static derivation across the entire graph dimension; If the derived dimension is incompatible with the expected dimension of the downstream node, and a connected path cannot be found in the directed graph of the data transformation, the error location and type are recorded and a second error list is generated. Diagnostic results are generated based on the first and second error lists, and the user is prompted to make corrections.

5. The method for generating and deploying a machine learning pipeline based on a graph structure according to claim 4, characterized in that, The framework topology verification includes: The flowchart information is parsed to construct a directed graph structure model that includes node attributes and edge relationships; Connectivity analysis and directed acyclicity detection are performed on the directed graph structure model to obtain the topology consistency verification results; Based on the verification results, locate and mark the subgraphs containing loops or broken chains, and generate a marking flowchart; Calculate the in-degree and out-degree of each node in the marked flowchart, perform dependency analysis, and deduce the process execution sequence; Based on the process execution sequence and preset node type rules, process specification verification is performed. If an anomaly is detected, the error type is recorded and a first error list is generated.

6. The method for generating and deploying a machine learning pipeline based on a graph structure according to claim 1, characterized in that, The process of mapping algorithm nodes in a signature library to specific algorithm signatures includes: Analyze the flowchart and extract the list of node requirements; Match the node requirement list with the algorithm signature library to obtain the node-algorithm candidate set; When a node type corresponds to multiple algorithm signatures, a weighted scoring and sorting process is performed on each candidate. The scoring combines the input / output interface matching degree, hardware resource consumption estimation, and the inner product of a preset business target vector. The target algorithm is determined based on the sorting results, and a node-algorithm mapping table is generated.

7. The method for generating and deploying a machine learning pipeline based on a graph structure according to claim 1, characterized in that, The generation of the executable pipeline containing the optimal fit subgraph includes: Perform a topological sort based on the updated graph structure to generate an execution sequence; Each node is bound to a parameter template and a default hyperparameter to form a parameter table and a component list; An intermediate representation of an executable pipeline is generated, which includes a node-algorithm mapping table, input / output interfaces, execution sequence, parameter table, component list, and resource binding information; The intermediate representation is converted into a Pipeline description to obtain an executable machine learning Pipeline.

8. The method for generating and deploying a machine learning pipeline based on a graph structure according to claim 1, characterized in that, The publishing service includes: Generate a service interface definition, which includes an inference-optimized description of the input and output tensor shapes; Package the model files, statistics files, and dependent components into an immutable deployment package with version numbers; Publish the model service API endpoint according to the service interface definition.

9. A system using the graph-based machine learning pipeline generation and deployment method as described in any one of claims 1-8, characterized in that, include: The process acquisition module is used to acquire machine learning flowcharts; The Pipeline generation module is used to build an algorithm signature library adapted to the characteristics of heterogeneous computing devices, including tensor shape constraints, symbolic dimension rules, and operator fusion modes; it parses the flowchart, and based on the signature library mapping nodes, it constructs a data transformation directed graph for edges with interface semantic conflicts and searches for the minimum cost adaptation path to generate an executable Pipeline containing the optimal adaptation subgraph. The Pipeline evaluation module is used to execute the Pipeline to complete the training evaluation. The Pipeline deployment module is used to identify feature engineering and model inference subgraphs if the evaluation meets the criteria, perform operator fusion optimization based on isomorphic matching on consecutive nodes according to the hardware instruction set of the target deployment environment, generate deployment packages and publish services.

Images