An automated computing power network orchestration system and method based on parameter-dependent algorithm

Abstract

This paper proposes an automated computing network orchestration system and method based on a parameter-dependent algorithm. The system comprises an interface document structured processing module, a parameter vectorization module, a dependency identification module, a topological sorting module, and an automatic process generation module. This system not only enhances the automation and intelligence of multi-element computing network orchestration, but also significantly improves the user experience, reduces labor costs, and enhances the system's adaptability and flexibility, ultimately driving innovation and efficient delivery of computing network products.

Description

Technical Field

[0001] The present invention relates to the field of computing power network technology, and in particular to an automated computing power network orchestration system and method based on a parameter-dependent algorithm. Background Art

[0002] With the rapid development of computing network technologies, traditional cloud-network combination services are no longer able to meet the demands of complex business scenarios. To address these challenges, integrated computing network services have emerged. Their core is to flexibly combine multiple elements—computing power, network, data, and intelligence—to orchestrate computing network solutions tailored to specific business scenarios. This new service model aims to transform traditional cloud-network combination services into integrated services that deeply integrate multiple elements, thereby driving innovation in computing network products.

[0003] In existing technologies, customers typically select and orchestrate the appropriate multi-factor computing network capabilities based on their business needs. However, this orchestration process is more than simply piling up the elements; it requires in-depth integration of each element's capabilities, completing the topology architecture, process design, and parameter configuration based on the synergy and logical relationships between the elements. This complex orchestration task presents a high professional threshold for most customers, especially when configuring the order in which elements are activated and parameter dependencies, often requiring the intervention of professional support personnel.

[0004] Existing technologies also suffer from complex process configuration, especially when multiple elements and capabilities are involved. Accurately orchestrating the processes and parameters between various elements not only ensures the correct implementation of the solution, but also must take into account the timeliness of implementation. Because orchestration involves multi-level and multi-dimensional coordination and integration, it is difficult to operate and the error rate increases. Furthermore, since process configuration relies on manual work by professional support personnel, this high reliance on manpower directly increases project labor costs. Furthermore, the limited number and capabilities of support personnel further restrict the innovation efficiency of computing network products.

[0005] Furthermore, under the existing orchestration model, the launch time for computing network solutions is long. The involvement of professional support personnel and complex process configuration slow down the overall progress, resulting in delayed solution launches and severely impacting the innovation speed and market responsiveness of computing network products. Customers have to wait a long time before they can use the orchestrated solutions, which impacts their business processes.

[0006] Therefore, existing multi-factor orchestration technologies for computing networks suffer from poor user experience, complex process configuration, high labor costs, and extended delivery times. These issues directly impact the innovation efficiency, user satisfaction, and market competitiveness of computing network products. Summary of the Invention

[0007] In order to overcome the shortcomings of the existing technology, the present invention proposes an automated computing power network orchestration system and method based on a parameter-dependent algorithm, which not only improves the automation and intelligence level of multi-factor orchestration of the computing network, but also significantly improves the user operation experience, reduces labor costs, enhances the adaptability and flexibility of the system, and ultimately promotes the innovation and efficient delivery of computing network products.

[0008] To achieve the above objectives, the present invention provides an automated computing power network orchestration system based on a parameter-dependent algorithm, comprising:

[0009] The interface document structured processing module is used to read and preprocess interface specification documents related to computing power network products, extract metadata such as interface name, interface code, interface service type, interface call address, interface protocol, input and output parameters, etc.; by cleaning irrelevant characters in the document (such as spaces, line breaks, invisible characters, etc.), and removing invalid lines (such as blank lines, contentless titles, duplicate lines, etc.), it ensures that the extracted metadata is accurate and complete, providing accurate basic data for subsequent dependency judgment.

[0010] The parameter vectorization module is used to vectorize the interface input and output parameters extracted through structured processing, and uses the BERT model to convert parameter descriptions into numerical vectors. The vectorization process includes word segmentation, semantic vectorization, and custom dictionary loading to improve the ability to handle professional terminology in computing network product interfaces and ensure more accurate calculation of semantic similarity between parameters.

[0011] The dependency identification module is used to calculate the dependencies between interfaces based on the vectorized parameters. It traverses the input parameters of each product interface and the output parameters of other product interfaces and calculates their cosine similarity. If the similarity is higher than the preset threshold (such as 0.85), it is determined that a dependency exists, and an interface dependency graph is established to mark the calling order between each product interface.

[0012] The topological sorting module is used to generate a business process diagram based on the dependency graph using a topological sorting algorithm (such as the Kahn algorithm). This module ensures that the generated process has no circular dependencies, calls each product interface in sequence, and generates correct business processes such as activation and cancellation.

[0013] The automatic process generation module is used to automatically generate the business process of the computing power network solution after topological sorting, including the input and output parameter configuration of the business process; the system automatically associates the corresponding parameters according to the dependency relationship of the interface, reducing manual intervention, quickly generating personalized business processes, and supporting customized optimized solutions based on business scenarios.

[0014] Furthermore, it also includes:

[0015] The parameter filtering module is used to pre-process interface input parameters before vectorization, excluding parameters that do not change with business scenarios and can be assigned default values, as well as invalid historical parameters, to reduce the computing burden and improve system processing efficiency.

[0016] Furthermore, it also includes:

[0017] The interface dependency library is used to store generated interface dependencies, including the input and output parameter association information of each product interface. Through the dependency library, the system can quickly infer and generate processes for different business solutions, thereby improving the efficiency of business process generation.

[0018] Furthermore, it also includes:

[0019] The parallel task optimization module is used to identify product interfaces that can be executed in parallel; by analyzing the dependencies between interfaces, interfaces without dependencies are grouped and executed in parallel, reducing the execution time of the solution and optimizing process performance.

[0020] Furthermore, it also includes:

[0021] The process visualization interface is used to display the generated solution topology and business process diagram, and supports users to make real-time adjustments to the product interface sequence and parameter configuration in the process through a graphical interface to enhance the user operation experience.

[0022] Furthermore, it also includes:

[0023] The process optimization module is used to optimize the generated business processes; the system simplifies the process, reduces repetitive operations and improves the overall execution efficiency of the system by eliminating redundant operations and merging the same or similar parameters.

[0024] An automated computing power network orchestration method based on a parameter-dependent algorithm, applicable to any of the above-mentioned automated computing power network orchestration systems based on a parameter-dependent algorithm, comprising:

[0025] Step 1: Read the interface documentation of the computing network product, clean and structure the documentation, and extract interface metadata and parameter metadata;

[0026] Step 2: Use word embedding technology to semantically vectorize the extracted parameters and filter out unnecessary parameters;

[0027] Step 3: Based on the vectorized parameters, calculate the dependencies between different interfaces and build a dependency graph;

[0028] Step 4: Sort the dependency graph using a topological sorting algorithm to generate the correct interface call sequence;

[0029] Step 5: Generate a business process diagram based on the topological sorting results, identify interfaces that can be executed in parallel, and optimize the process execution order;

[0030] Step 6: Merge similar parameters in the generated process, remove redundant parameters, and build an optimized parameter tree;

[0031] Step 7: Optimize the execution efficiency of business processes by reducing redundant operations and parallelizing execution.

[0032] Furthermore, step 1 is as follows:

[0033] Step 11: Read the interface specification documents related to the computing network product;

[0034] Step 12: Clean up irrelevant characters (such as spaces, tabs, line breaks, illegal characters, etc.) in the document;

[0035] Step 13: Remove invalid lines (such as blank lines, comment lines, and duplicate lines) from the document and extract interface metadata and parameter metadata, including interface name, interface code, product to which the interface belongs, service type (activation, change, cancellation, etc.), input and output parameters, and their attributes;

[0036] Step 14: Use natural language processing tools (such as THULAC word segmentation tools) to segment the interface description and parameter description to extract descriptive key information;

[0037] Step 2 is as follows:

[0038] Step 21: Use word embedding technology to process the extracted parameter metadata and use the BERT model to convert the parameter text into a semantic vector;

[0039] Step 22: Filter out default parameters that do not need to be dynamically changed and invalid historical parameters to reduce unnecessary performance consumption;

[0040] Step 23: Concatenate the parameter description information and other related metadata into a string and input it into the BERT model to generate the parameter's feature vector for subsequent dependency calculation.

[0041] Furthermore, step 3 is as follows:

[0042] Step 31: Construct the input and output parameter set of the product interface, and extract the input parameters (Pin) and output parameters (Pout) of each product interface;

[0043] Step 32: Calculate the cosine similarity between the output parameters of the interfaces between different products and the input parameters of other products;

[0044] Step 33: Determine whether there is a dependency relationship between the interfaces based on the similarity value. If the cosine similarity is greater than a preset threshold (e.g., 0.85), it is considered that the two interfaces have a dependency relationship, and the dependency relationship is recorded.

[0045] Step 4 is as follows:

[0046] Step 41: Build a dependency graph of the solution based on the identified interface dependencies;

[0047] Step 42: Use a topological sorting algorithm (such as the Kahn algorithm) to sort the dependency graph to ensure that the starting product interface of each directed edge in the graph is called before the end product interface;

[0048] Step 43: If a loop (i.e., circular dependency) is found in the graph, the user is prompted to adjust the topology to ensure the correctness of the process.

[0049] Furthermore, step 5 is as follows:

[0050] Step 51: Generate a business process diagram based on the results of the topological sorting to clarify the calling sequence of each product interface;

[0051] Step 52: After the flow chart is generated, the system identifies product interfaces that can be executed in parallel and groups interfaces without dependencies for parallel execution;

[0052] Step 53: For interfaces with dependencies, call them in sequence to ensure the logic of process execution;

[0053] Step 6 is as follows:

[0054] Step 61: Extract the input and output parameters of each interface in the generated flow chart and construct the parameter tree structure of input and output parameters;

[0055] Step 62: Remove the redundant parameters that have been relied upon in the parameter tree according to the identified inter-interface dependency relationship;

[0056] Step 63: Calculate semantic similarity for the remaining parameters, merge similar parameters, and process them uniformly in the process to reduce duplication of operations;

[0057] Step 7 is as follows:

[0058] Step 71: After generating the flowchart, continue to identify redundant operations in the process to reduce unnecessary repeated calls;

[0059] Step 72: Further improve the process execution efficiency by optimizing and merging similar parameters and parallelizing the execution strategy.

[0060] Compared with the prior art, the present invention has the following beneficial effects:

[0061] This invention provides an automated computing network orchestration system and method based on a parameter-dependent algorithm. By introducing a topological sorting algorithm and a semantic vectorization algorithm, the system automatically analyzes the interface specification documents of computing network products, builds a library of interface dependencies, and automatically generates the solution's business processes and their input and output parameters. This automated function significantly reduces the need for manual intervention, improves the accuracy and efficiency of orchestration, and makes the complex computing network orchestration process more intelligent.

[0062] 2. This invention provides an automated computing network orchestration system and method based on a parameter-dependent algorithm. This system provides an intuitive visual orchestration interface, allowing users to orchestrate the solution's topology architecture with a simple drag-and-drop operation. The system then automatically generates business processes and parameter configurations. This significantly simplifies the traditional manual intervention process, saving time and enabling users to complete complex orchestration tasks more flexibly and quickly, significantly improving the user experience.

[0063] 3. This invention provides an automated computing network orchestration system and method based on a parameter-dependent algorithm. While existing technologies rely heavily on manual labor, this system significantly reduces reliance on specialized personnel and lowers labor costs through intelligent, automated orchestration. Furthermore, because the automated process improves orchestration efficiency, the time it takes to launch a solution is shortened, directly improving the overall efficiency and market competitiveness of computing network services.

[0064] 4. This invention provides an automated computing network orchestration system and method based on a parameter-dependent algorithm. This system is highly flexible and adaptable, enabling rapid response to diverse customer needs and dynamic adjustment and customization based on changing business scenarios. This technical solution can flexibly adapt to changing business needs without requiring multiple manual adjustments, significantly improving the system's adaptability and meeting the needs of diverse application scenarios. BRIEF DESCRIPTION OF THE DRAWINGS

[0065] In order to more clearly illustrate the specific embodiments of the present invention or the technical solutions in the prior art, the following is a brief introduction to the drawings required for use in the specific embodiments or the description of the prior art. Obviously, the drawings described below are some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0066] Figure 1 This is an example diagram of the overall process of the present invention;

[0067] Figure 2 This is a schematic diagram of the topological architecture of the Sunshine Kitchen solution of the present invention;

[0068] Figure 3 This is a schematic diagram of the interface dependency of the process of opening the present invention;

[0069] Figure 4 This is a schematic diagram of the optimized business process of the present invention. DETAILED DESCRIPTION

[0070] The technical solutions of the present invention will be more clearly and completely explained below through description of preferred embodiments of the present invention in conjunction with the accompanying drawings.

[0071] The present invention performs data pre-processing and structured extraction of interface key information and parameter key information on the interface specification documents related to the product capabilities of each element of the computing network (hereinafter referred to as "products"), and then uses a semantic vectorization algorithm to identify the parameter dependencies between different product interfaces, thereby establishing dependencies between different products, that is, the order of activation. After the customer selects multiple products to complete the topological architecture arrangement of the solution, the system selects the interfaces of the corresponding products according to the topological architecture and product dependency structure to build an interface dependency graph, calculates and generates the business process of the solution through a topological sorting algorithm, and automatically generates the input parameters and output parameters of the business process of the solution by using the parameter dependencies between different product interfaces that have been vectorized in the early stage. An example of the overall process of the solution is as follows: Figure 1 shown.

[0072] Main implementation logic:

[0073] Structural processing of interface documents

[0074] The system pre-reads the interface specification documents related to various computing network products and pre-processes the contents of the interface documents. This includes cleaning irrelevant characters, invalid lines, and other information in the documents. The cleaning content includes:

[0075] Irrelevant characters: including space characters at the beginning and end of the text, invisible characters, tab characters, line breaks, illegal characters, repeated punctuation and other irrelevant characters.

[0076] Invalid lines: include blank lines, comment lines, short characters on a separate line, repeated lines, empty tables, titles with no content, and other invalid lines.

[0077] After the cleaning is completed, the title, table (interface input parameters, output parameters), interface description and other information at all levels in the document are extracted, and the corresponding key metadata are extracted according to the interface and parameter dimensions:

[0078] Interface metadata: interface name, interface code, interface product, interface service type (activation, change, cancellation, etc.), interface call address, interface protocol, interface description and other data.

[0079] Parameter metadata: parameter name, parameter code, attributed interface, attributed product, attributed interface service type, parameter type, parameter description, parameter value range, parameter unit and other data.

[0080] Since some key metadata are text descriptions, such as interface descriptions and parameter descriptions, in order to ensure accurate metadata extraction, the THULAC word segmentation tool is used to segment descriptive texts such as interface descriptions and parameter descriptions, and then the required key information is obtained based on the word segmentation results.

[0081] THULAC (THU Lexical Analyzer for Chinese) is a Chinese lexical analysis toolkit developed by the Natural Language Processing and Social Humanities Computing Laboratory of Tsinghua University. THULAC can accurately segment Chinese text into meaningful vocabulary units, supports the effective recognition of common words, new words, and network terms, and performs part-of-speech tagging during word segmentation. At the same time, the interface specification document contains many professional categories of vocabulary due to its high degree of professionalism. In order to further improve the accuracy of word segmentation, a set of custom dictionaries specifically for computing network products is pre-configured and loaded into THULAC for word segmentation. For example, for the parameter description "IP address of the server used to access the camera", the key information "camera server IP address" can be obtained by extracting the nouns according to the part of speech based on the word segmentation results.

[0082] After extracting the interface metadata and parameter metadata, construct structured data in JSON format.

[0083] Parameter vectorization

[0084] The system uses word embedding technology Bert to vectorize the parameter structured data generated in the above steps. The vectorized data will be used to determine the parameter dependency in the next step.

[0085] Word embedding technology converts words in natural language into numerical vectors. By representing each word as a multi-dimensional numerical vector, these vectors can capture the semantic relationships between words. The core concept of word embedding technology is based on distributed representation, that is, the meaning of a word can be inferred from its context in the text. By mapping words into a low-dimensional continuous vector space, it improves the performance and accuracy of natural language processing (NLP) tasks. Word embedding technology is widely used in various NLP tasks, such as text classification and machine translation. It enables computers to more efficiently process and understand natural language text, thereby achieving more complex language processing tasks.

[0086] Bert, a pre-trained language model based on the Transformer architecture, acquires rich linguistic knowledge and deep semantic representations through pre-training on a large corpus. When applied to specific tasks, Bert can quickly adapt through fine-tuning, providing more accurate and powerful support for text vectorization. Therefore, the system selected Bert as the word embedding technology in the hope of achieving better performance in subsequent processing.

[0087] The specific steps are as follows:

[0088] When vectorizing parameters, to reduce unnecessary performance consumption and reduce the complexity of subsequent parameter dependency judgment, you need to filter the parameters first. The filtering rules are as follows:

[0089] For interface input parameters, they will not change with changes in business scenarios and can be directly assigned default values.

[0090] For interface input parameters, parameters that were added for historical reasons but are no longer in use

[0091] The key metadata of the extracted parameters is concatenated into a string according to the parameter dimension and used as the input of BERT. Among these metadata, text description attributes such as parameter descriptions have been segmented and sorted in advance. The remaining attributes are already standardized in the interface specification document, ensuring data consistency and comparability, so no additional special processing is required. For example, for the camera ID parameter in a certain interface, its key metadata is:

[0092] {

[0093] "Parameter name": "Camera ID",

[0094] "Parameter encoding": "cameraId",

[0095] "Service Type of Home Interface": "Service Activation",

[0096] "Parameter type": "String",

[0097] "Parameter Description": "Camera ID",

[0098] "Parameter value range": "",

[0099] "Parameter Unit": ""

[0100] }

[0101] The concatenated string is: "Camera ID [SEP] cameraId [SEP] AI analysis task creation [SEP] AI algorithm [SEP] service activation [SEP] String [SEP] camera id [SEP] [SEP] [SEP]"

[0102] Among them, "[SEP]" is a special token in BERT. When processing multiple text fragments, [SEP] is used to separate these text fragments to help the model understand the structure of the input sequence.

[0103] Load a Bert model tokenizer and convert the concatenated string into a numeric sequence that the Bert model can process.

[0104] from transformers import BertModel

[0105] #Load the Tokenizer from the BERT model

[0106] tokenizer = BertTokenizer.from_pretrained('bert-base-multilingual-uncased')

[0107] # Perform word segmentation on the specified texts

[0108] inputs = tokenizer(texts, return_tensors='pt', padding=True,truncation=True, max_length=512)

[0109] return_tensors: This parameter specifies the data type returned by the tokenizer. 'pt' means returning PyTorch tensors.

[0110] padding: When this parameter is set to True, it instructs the tokenizer to pad all processed texts to ensure that they have the same length.

[0111] truncation: When this parameter is set to True, it instructs the tokenizer to truncate texts when necessary to ensure that their length does not exceed a certain maximum value, preventing the processing of overly long texts, which may consume too much computing resources or cause the model performance to degrade.

[0112] max_length: This parameter specifies the maximum length of the text. Currently it is set to 512. All processed text will be truncated or padded to this length.

[0113] The processed text and number sequence is input into the BERT model, and the hidden state of BERT's last layer is extracted as a feature vector. BERT's last hidden state contains information about the input text after it has been processed by the multi-layer Transformer structure. This information includes both the semantic content of the text and its contextual relationships, making it ideal as a feature vector for subsequent tasks.

[0114] from transformers import BertModel

[0115] #Load the Bert model

[0116] model = BertModel.from_pretrained('bert-base-multilingual-uncased')

[0117] #Use the loaded BERT model to forward propagate the input data and obtain the output of the model

[0118] outputs = model(**inputs)

[0119] #Extract the representation of the last hidden layer from the output of the model, take the representation of the first token, and then add a batch dimension

[0120] embeddings1 = outputs.last_hidden_state[:, 0, :].unsqueeze(0)

[0121] Build an interface dependency library

[0122] The system builds an interface dependency library based on the interface, parameter metadata, and vectorized data. The construction process includes the following steps:

[0123] Parameters are grouped in order according to the interface, interface business type in parameter metadata, and the product to which they belong. For example, first extract the input and output parameters from the product C service activation interface. , This is the input parameter for product C in the service activation interface. This is the output parameter of product C in the service activation interface. The input and output parameters of the service activation interfaces of other products are extracted in sequence to form the product dimension parameter set of the service activation interface. . Each element in the set Contains all input and output parameters of a specific product in the service activation interface.

[0124] The dependency of interfaces is established by associating the output and input parameters between interfaces. Specifically, if product A opens an output parameter in interface I1 , used as input parameter in the activation interface I2 of product B , then it means that you need to call interface I1 first, and then call interface I2, which is recorded as I1→I2.

[0125] In order to systematically identify and construct the dependency relationship between interfaces of different products under a certain business type, we need to During the traversal, we calculate Each output parameter below is consistent with the other elements in the collection The cosine similarity between each input parameter under (m ≠ n). Through this method, we can accurately determine the dependency relationship between interfaces, that is, if the output parameters of one interface are highly similar to the input parameters of another interface, it can be determined that the latter depends on the former. The feature vector of a certain output parameter obtained in the previous step is embeddings1, The feature vector of the output parameter obtained in the previous step is embeddings2, and the cosine similarity calculation code is as follows:

[0126] from torch.nn.functional import cosine_similarity

[0127] # Calculate cosine similarity

[0128] similarity = cosine_similarity(embeddings1, embeddings2)

[0129] # Get the average cosine similarity between two parameters (tensors)

[0130] cosine_similarity = similarity.mean().item()

[0131] For each element in the set P After all traversals are completed, the cosine similarity between each input and output parameter can be calculated. The closer the cosine similarity between two parameters is to 1, the higher the degree of similarity between the two parameters in direction. Based on the current interface specification, we set the preset threshold to 0.85. In actual applications, the setting of the specific threshold needs to be judged and adjusted according to the actual situation. When the calculated similarity exceeds this preset threshold, it can be determined that there is a correlation between the two parameters, and then it can be inferred that there is a dependency relationship between the interfaces to which they belong, and the interface dependency library is constructed accordingly. For example, in the output parameters of the video cloud activation interface, there is parameter A, and its metadata is:

[0132] {

[0133] "Parameter name": "Camera ID",

[0134] "Parameter encoding": "cameraId",

[0135] "Service Type of Home Interface": "Service Activation",

[0136] "Parameter type": "String",

[0137] "Parameter Description": "Platform Camera Id",

[0138] "Parameter value range": "",

[0139] "Parameter Unit": ""

[0140] }

[0141] Among the input parameters in the AI ​​algorithm analysis task creation interface, there is a B parameter, and its metadata is:

[0142] {

[0143] "Parameter name": "Camera ID",

[0144] "Parameter encoding": "cameraId",

[0145] "Service Type of Home Interface": "Service Activation",

[0146] "Parameter type": "String",

[0147] "Parameter Description": "Camera ID",

[0148] "Parameter value range": "",

[0149] "Parameter Unit": ""

[0150] }

[0151] The cosine similarity between the two parameter vectors is 0.9036458134651184, indicating that the two parameters are similar. Output parameter A of the Video Cloud Activation API is used as input parameter B in the AI ​​Algorithm Analysis Task Creation API. This indicates that if both the Video Cloud and AI Algorithm products are activated simultaneously, the Video Cloud Activation API is required before calling the AI ​​Algorithm Analysis Task Creation API.

[0152] Build a solution process interface dependency diagram

[0153] Customers create a computing network solution based on their business needs. Through a visual interface, they select multiple appropriate computing network product capabilities and orchestrate the solution's topology. The system then identifies the products involved and the data relationships between them. Using a pre-established interface dependency library, the system selects eligible interfaces and their dependencies, constructing a DAG (directed acyclic graph) interface dependency graph for the solution's activation and cancellation processes. Using the Sunshine Kitchen solution as an example, the detailed construction of the activation process interface dependency graph is as follows:

[0154] The topology of the Sunshine Kitchen solution is as follows: Figure 2 As shown,

[0155] Based on this topology, the Sunshine Kitchen solution involves products including: camera terminals, cloud dedicated lines, video cloud, cloud networking, and AI algorithms. The data relationships between these products are: camera terminals <-> cloud dedicated lines, cloud dedicated lines <-> video cloud, video cloud <-> cloud networking, and cloud networking <-> AI algorithms.

[0156] Based on the products involved, the interfaces and their dependencies selected from the interface relationship dependency library include: cloud dedicated line → camera terminal, video cloud → camera terminal, video cloud → cloud dedicated line, video cloud → cloud networking, AI algorithm → cloud networking, AI algorithm → cloud dedicated line, video cloud → AI algorithm.

[0157] After filtering based on the data relationships between products, the interfaces and their dependencies involved in the business process of this solution are finally obtained, including: cloud dedicated line → camera terminal, video cloud → camera terminal, video cloud → cloud dedicated line, video cloud → cloud networking, AI algorithm → cloud networking, video cloud → AI algorithm.

[0158] The above relationship is converted into directed edges: (video cloud, camera terminal), (video cloud, cloud networking), (video cloud, cloud dedicated line), (video cloud, AI algorithm), (cloud dedicated line, camera terminal), (AI algorithm, cloud networking).

[0159] A directed edge is a fundamental concept in graph theory. It refers to an edge with a direction. In a directed graph, an edge connects two vertices and has a clear starting point and an end point. Directed edges are typically represented by arrows, with the direction of the arrow indicating the direction of the edge. In a directed graph, the direction of an edge is crucial, as it determines the reachability between vertices.

[0160] Construct the interface dependency graph of the opening process by using directed edges, such as Figure 3 As shown,

[0161] Automatically generate solution flowchart

[0162] The system uses the Kahn algorithm to topologically sort the interface dependency graph generated in the previous step, ensuring that for every directed edge (u, v) in the graph, u appears before v (in the sorted record). The system then automatically compiles a solution flowchart based on the topological sorting results. The Kahn algorithm is a topological sorting algorithm for directed acyclic graphs (DAGs). It achieves a topological sort by continuously removing vertices with in-degree 0 until all vertices are visited. The detailed steps are as follows:

[0163] Calculate the in-degree of each vertex in the graph. In-degree refers to the number of edges pointed to by other vertices in a vertex in the graph. For example, if a→b, the in-degree of b is 1. The final in-degrees of each vertex in the graph are shown in Table 1, which are:

[0164] Table 1

[0165]

[0166] Create two empty queues, S and Q, respectively. S is used to store the sorted vertex order; Q is used to store vertices with in-degree 0. Currently, all vertices with in-degree 0 are added to queue Q, and queue Q = [Video Cloud].

[0167] Take a vertex v from queue Q and add it to queue S. After traversing all adjacent vertices w of vertex v, for each adjacent vertex w, reduce its in-degree by 1 (that is, remove an edge from v to w). After this operation, if the in-degree of a vertex w becomes 0, add it to queue Q. At this point, queue S = [Video Cloud], and queue Q = [Cloud Dedicated Line, AI Algorithm].

[0168] Repeat the previous step until queue Q is empty. At this point, queue S is the sorted vertex order, that is, the linear product interface call order. Queue S = [Video Cloud, Cloud Dedicated Line, AI Algorithm, Camera Terminal, Cloud Networking].

[0169] If, after the algorithm completes, the number of vertices in queue S is less than the total number of vertices in the graph, a cycle exists in the graph. Because vertices in a cycle cannot be completely removed through the above process, their in-degree never reaches 0 and therefore cannot be added to the resulting list of topological sorts. In practice, if this occurs, it's usually because the solution's topology architecture has incorrectly configured data relationships, requiring the customer to adjust the topology architecture according to the prompts.

[0170] To improve business process efficiency, it is necessary to continue searching for product interfaces that can be called in parallel. Traverse queue S and, for each product interface, check whether there is a dependency relationship with its subsequent product interfaces. If there is no dependency, these product interfaces can be called and executed in parallel. Group these product interfaces so that the product interfaces within each group can be processed in parallel. For product interfaces with dependencies, continue calling them in the order of topological sorting. Taking the Sunshine Kitchen solution as an example, its sorted queue S = [Video Cloud, Cloud Dedicated Line, AI Algorithm, Camera Terminal, Cloud Networking], and perform a cyclic judgment on this queue:

[0171] Take the first product interface "Video Cloud". It has a dependency with the subsequent product interface "Cloud Dedicated Line" and cannot be processed in parallel. Therefore, create the first parallel group S1=[Video Cloud].

[0172] Continue to take the second product interface "Cloud Dedicated Line". There is no dependency between it and the subsequent product interface "AI Algorithm" and they can be processed in parallel, so create a second parallel group. =[Cloud dedicated line, AI algorithm].

[0173] use The product interface in the continues to judge with the subsequent interface, because There is a dependency between the "Cloud Dedicated Line" and the subsequent product interface "Camera Terminal", so End of parallel grouping.

[0174] Continue to judge from the "camera terminal", it has no dependency with the subsequent product interface "cloud networking", and can be processed in parallel, so create a third parallel group =[Camera terminal, cloud network]. At this time, the interface in queue S has been judged to be completed. End of parallel grouping.

[0175] After the parallel grouping is completed, the parallel groups are processed sequentially. In the parallel group, there is only the product interface "Video Cloud", so it is placed in the first link of the business process; The parallel group contains two product interfaces, "Cloud Dedicated Line" and "AI Algorithm," which are placed in parallel in the second link of the business process. Because both interfaces depend on the product interface "Video Cloud" in the first link, a relationship is set from "Video Cloud" to these two interfaces. There are also two product interfaces "Camera Terminal" and "Cloud Network" in the parallel group, which are placed in parallel in the third link of the business process. Since these two interfaces rely on the product interfaces "Cloud Dedicated Line" and "AI Algorithm" in the second link respectively, starting from the product interfaces in the second link, the relationship pointing to the corresponding interfaces in the third link is set. At this point, the optimized business process is automatically generated. The generated optimized business process is as follows Figure 4 As shown;

[0176] Automatically generate solution process input and output parameters

[0177] After the business process is generated, the input and output parameters of each interface in the process are processed, and the parameters with dependencies are excluded. For the remaining parameters, they are vectorized and then cosine similarity is judged. The same parameters are merged, and finally the input and output parameters of the process are generated according to the parameter path. The detailed steps are as follows:

[0178] Extract the input and output parameters of each interface in the process and construct the input and output parameter trees respectively. Each parameter tree has a first-level node consisting of a common node and several interface nodes, with the parameters being the leaf nodes of the tree. Taking the automatic construction of input parameters for the Sunshine Kitchen solution's service activation process as an example, the input parameter tree structure is shown in Table 2:

[0179] Table 2

[0180]

[0181] According to the inter-interface parameter dependency relationship obtained in step C, the corresponding parameter leaf nodes in the parameter tree are identified and removed. After removing the dependent parameters, the parameter tree structure is shown in Table 3:

[0182] Table 3

[0183]

[0184] Based on the parameter vector obtained in step B, starting from the parameters under the first interface node in the parameter tree, the cosine similarity of the parameters of each leaf node under it and the parameters of the leaf nodes under the remaining interface nodes in the parameter tree is calculated in sequence. If the cosine similarity of two parameters exceeds the preset threshold (preset threshold = 0.85), it can be determined that the two parameters have the same meaning and are merged into a new parameter. Subsequently, the two original parameters are removed from the interface nodes to which they originally belonged, and the merged new parameters are added to the common node. When adding to the common node, for parameter nodes with the same meaning, the hierarchical information of the first parameter node identified as having the same meaning is used.

[0185] Remove it from the corresponding interface node and add the merged new parameter to the public node. When adding to the public node, for parameter nodes with the same meaning, take the first parameter node level and add it to the public node.

[0186] For example, starting from the first parameter "Order Number" under the "Video Cloud Service Activation Interface", we first calculate the cosine similarity between it and the first parameter "Group Number" under the "Cloud Dedicated Line Service Activation Interface". The calculated result is 0.8125, indicating that they are different parameters. Then, we continue to calculate the cosine similarity with the next parameter "Customer Order Number". The calculated result is 0.9479, which is greater than the preset threshold. Therefore, it is determined that the two parameters have the same meaning and can be merged into one parameter.

[0187] After traversing the parameters under the first interface, continue to start from the parameters under the second interface node in the parameter tree and repeat the above steps until the parameters under all interface nodes in the parameter tree are traversed. Finally, the input parameter tree structure of the Sunshine Kitchen Solution service activation process is shown in Table 4:

[0188] Table 4

[0189]

[0190] At this point, the parameter tree is the input or output parameter of the streamlined, merged and optimized business process.

[0191] As a specific implementation method: Application of an automated computing power network orchestration system based on parameter-dependent algorithms

[0192] System deployment environment

[0193] The system can be deployed on a distributed cloud platform to process a large amount of interface data from computing network products and complex business process orchestration. The system includes the following main modules:

[0194] Interface document parsing module: supports interface specification documents in different formats (such as JSON, XML, and text files);

[0195] BERT vectorization module: vectorizes parameters through the BERT model;

[0196] Dependency identification module: calculates parameter dependencies and builds a dependency graph;

[0197] Topological sorting module: sorts the dependency graph and generates an executable business process diagram;

[0198] Visualization module: provides users with an intuitive interface for adjusting and viewing the generated flowchart.

[0199] The system supports containerized deployment and uses Docker to package, deploy and expand applications.

[0200] The implementation steps are as follows:

[0201] Reading and preprocessing interface documents: The system first reads the interface specification documents for the computing network products from a database or file storage. These documents may be stored in various formats, including XML, JSON, etc. The documents are stored in a file system. Each document contains product interface information, such as input parameters, output parameters, and interface description.

[0202] Preprocessing process:

[0203] The system uses regular expressions to identify and clean irrelevant characters (such as spaces, line breaks, etc.) in documents;

[0204] Remove invalid lines (such as blank lines, duplicate lines, etc.);

[0205] Extract valid data into structured data (JSON format), including interface name, input parameters, output parameters, etc.

[0206] For example, an interface document might contain the following data:

[0207] {

[0208] "Interface Name": "Camera Initialization",

[0209] "Input parameters": [

[0210] {"Parameter name": "Camera ID", "Type": "String"},

[0211] {"Parameter name": "Camera position", "Type": "String"}

[0212] ],

[0213] "Output parameters": [

[0214] {"Parameter name": "Initialization result", "Type": "Boolean"} ]

[0216] }

[0217] Parameter vectorization: After the interface document is preprocessed, the system uses the BERT model to vectorize the parameter description text. The system loads the pre-trained BERT model and converts the description information of each parameter into a high-dimensional vector.

[0218] For example, for the "camera ID" and "camera position" parameters in the above interface, the system converts them into vector representations of specific dimensions for subsequent similarity calculations.

[0219] The vectorization process uses the following steps:

[0220] Perform word segmentation on each parameter, for example, "camera ID" will be segmented into ["camera", "ID"];

[0221] The word segmentation results are input into the BERT model to generate vector representations, such as:

[0222] from transformers import BertTokenizer, BertModel

[0223] tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')

[0224] model = BertModel.from_pretrained('bert-base-chinese')

[0225] inputs = tokenizer("camera ID", return_tensors="pt")

[0226] outputs = model(**inputs)

[0227] The output is a high-dimensional vector for subsequent dependency identification.

[0228] Dependency identification: The system calculates the similarity of the input parameters and output parameters of all interfaces, and determines whether there is a dependency relationship between different product interfaces by calculating the cosine similarity. The specific steps for dependency identification are as follows:

[0229] The output parameters of each interface are compared with the input parameters of other interfaces one by one, and the cosine similarity is calculated. Assume that the vector of output parameter A is represented as vector_A and the vector of input parameter B is represented as vector_B. Calculate the similarity between them:

[0230] from numpy import dot

[0231] from numpy.linalg import norm

[0232] cosine_similarity = dot(vector_A, vector_B) / (norm(vector_A) * norm(vector_B))

[0233] When the similarity is greater than 0.85, the system considers these parameters to be dependent. For example, the output parameter of "Camera ID" may be used as the input parameter of the next interface, thus forming a dependency relationship between the interfaces.

[0234] The recognition results generate a dependency graph (DAG) that records the dependency order between interfaces. The nodes of the graph represent interfaces, and the edges represent dependency relationships.

[0235] Topological sorting and flow chart generation: After dependency identification is complete, the system topologically sorts the dependency graph to determine the execution order of each product interface. The system uses the Kahn algorithm to sort the DAG to ensure there are no circular dependencies.

[0236] The system prioritizes all nodes with in-degree 0 (interfaces without dependencies), gradually removing the nodes and recording their execution order.

[0237] For each node removed, update the in-degree of the adjacent nodes until all nodes in the graph have been processed.

[0238] The generated sorting results are used to construct a business process graph, where each node represents an interface call and the edges represent the order of the calls.

[0239] Automatic process generation and parameter configuration: The system automatically generates a business process diagram based on the sorting results and configures the input and output parameters of each interface.

[0240] The input parameters of each interface are automatically inherited from the output parameters of the previous interface. For example, the output "Initialization Result" of "Camera Initialization" will be used as the input of the next interface and automatically configured in the flowchart.

[0241] If the input parameters of two or more interfaces are found to be similar, the system automatically merges these parameters to reduce duplication of configuration.

[0242] Parallel Task Optimization: After generating a flowchart, the system analyzes which interfaces can be executed in parallel. For example, if certain interfaces have no dependencies and can be executed simultaneously, the system will group these interfaces to optimize process execution time.

[0243] The parallelization optimization strategy is to analyze the nodes without direct connections in the dependency graph and allow them to be executed simultaneously in different threads or processes, thereby improving the execution efficiency of the entire solution.

[0244] Visualization interface display: The system provides a graphical interface that displays the generated business process diagram through the front end. Users can adjust the nodes in the process by dragging and dropping. The system will automatically regenerate the dependency diagram and update the topological sorting results.

[0245] In the interface, users can view detailed information of each node, including parameter configuration, dependencies, execution order, etc.

[0246] The system supports users to adjust parameters, display the adjusted flow chart in real time, and dynamically generate new processes.

[0247] Implementation Case: Computing Power Orchestration for Camera Intelligent Monitoring Systems

[0248] Assume that the user wants to use this system to generate a business process for a camera intelligent monitoring system. This monitoring system requires:

[0249] Initialize the camera;

[0250] Connect to the cloud server;

[0251] Perform video analysis.

[0252] Through the system's automatic orchestration, the process is as follows:

[0253] Camera initialization interface: Input: camera ID, camera position;

[0254] Output: Initialization result.

[0255] Cloud server connection interface: Input: camera ID, server address;

[0256] Output: Connection status.

[0257] Video analysis interface: Input: camera ID, connection status;

[0258] Output: Analysis results.

[0259] The system automatically identifies the dependencies between the camera IDs and the three interfaces and generates an executable flow chart. The input and output parameters of each interface are automatically configured within the flow, and users can view the entire process through a visual interface and make adjustments as needed.

[0260] This implementation demonstrates how to orchestrate complex computing network products in real-world scenarios and generate complete business processes through an automated computing network orchestration system based on parameter dependency algorithms. This system eliminates the need for users to manually configure dependencies and parameters for each interface, significantly improving orchestration efficiency.

[0261] The above-described specific embodiments merely describe preferred embodiments of the present invention and do not limit the scope of protection of the present invention. Any modifications, substitutions, and improvements made to the technical solution of the present invention by a person skilled in the art based on the textual description and drawings provided herein, without departing from the design concept and spirit of the present invention, shall fall within the scope of protection of the present invention. The scope of protection of the present invention is determined by the claims.

Claims

1. An automated computing network orchestration system based on parameter-dependent algorithms, characterized by include: The interface document structured processing module is used to read and extract interface metadata and parameter metadata from the computing network product interface documents, perform structured processing, and provide input data for dependency identification; The parameter filtering module is used to filter the input parameters in the metadata before parameter vectorization, excluding default parameters that do not change with business scenarios and historical parameters that are no longer used, thereby improving system performance and ensuring the accuracy of dependencies; The parameter vectorization module is used to perform semantic vectorization on the extracted metadata. It uses the BERT model to convert parameter descriptions into numerical vectors, including word segmentation, semantic vectorization, and custom dictionary loading. The dependency identification module is used to calculate the dependency between interfaces based on the vectorized parameters. By calculating the cosine similarity between the interface parameters of different products, when the similarity is higher than the preset threshold of 0.85, it is determined that a dependency exists and a product interface dependency graph is established. The topological sorting module is used to determine the execution order of product interfaces based on the dependency graph using a topological sorting algorithm to generate a business process diagram with acyclic dependencies. Interface dependency library, used to store dependency information of interfaces of different computing power network products; The interface dependency library dynamically updates and maintains the dependencies between interfaces, providing a reference for subsequent process generation; The automatic process generation module is used to automatically generate business processes based on the topological sorting results, and automatically configure the input and output parameters in the process through parameter dependencies, thereby realizing the automated orchestration and customized processing of business processes; The parallel task optimization module is used to analyze the product interface dependencies in the business process after it is generated, identify product interfaces that can be executed in parallel, and group them for parallel execution; The process visualization interface is used to provide a visual display of business processes, showing the generated topology structure and business process diagram, and supports users to adjust the product interface in the process and update the business process diagram in real time; The process optimization module is used to optimize the generated business processes and reduce repeated operations by merging similar or redundant parameters.

2. A method for arranging an automated computing power network based on a parameter-dependent algorithm, applicable to the automated computing power network orchestration system based on a parameter-dependent algorithm as claimed in any one of claims 1, characterized in that: include: Step 1: Read the interface documentation of the computing network product, clean and structure the document, and extract the interface metadata and parameter metadata. Step 1 is as follows: Step 11: Read the interface specification documents related to the computing network product; Step 12: Clean up irrelevant characters in the document; Step 13: Remove invalid lines from the document and extract interface metadata and parameter metadata, including interface name, interface code, product to which the interface belongs, business type, input and output parameters, and their attributes; Step 14: Use natural language processing tools to segment the interface description and parameter description to extract descriptive key information; Step 2: Use word embedding technology to semantically vectorize the extracted parameters and filter out the parameters; Step 2 is as follows: Step 21: Use word embedding technology to process the extracted parameter metadata and use the BERT model to convert the parameter text into a semantic vector; Step 22: Filter out default parameters that do not need to be dynamically changed and invalid historical parameters to reduce performance consumption; Step 23: Concatenate the parameter description information and metadata into a string and input it into the BERT model to generate the parameter feature vector for subsequent dependency calculation; Step 3: Based on the vectorized parameters, calculate the dependencies between different interfaces and build a dependency graph. Step 3 is as follows: Step 31: Construct the input and output parameter set of the product interface and extract the input parameters and output parameters of each product interface; Step 32: Calculate the cosine similarity between the output parameters of the interfaces between different products and the product input parameters; Step 33: Determine whether there is a dependency relationship between the interfaces based on the cosine similarity value. If the cosine similarity is greater than a preset threshold of 0.85, it is considered that the two interfaces have a dependency relationship, and the dependency relationship is recorded. Step 4: Sort the dependency graph using a topological sorting algorithm to generate the correct interface call sequence. Step 4 is as follows: Step 41: Build a dependency graph of the solution based on the identified interface dependencies; Step 42: Use a topological sorting algorithm to sort the dependency graph to ensure that the starting product interface of each directed edge in the graph is called before the end product interface; Step 43: If a loop (i.e., circular dependency) is found in the graph, the user is prompted to adjust the topology to ensure the correctness of the process; Step 5: Generate a business process diagram based on the topological sorting results, identify interfaces that can be executed in parallel, and optimize the process execution order; Step 5 is as follows: Step 51: Generate a business process diagram based on the results of the topological sorting to clarify the calling sequence of the product interfaces; Step 52: After the flow chart is generated, the system identifies product interfaces that can be executed in parallel and groups interfaces without dependencies for parallel execution; Step 53: For interfaces with dependencies, call them in sequence to ensure the logic of process execution; Step 6: Merge similar parameters in the generated process, remove redundant parameters, and build an optimized parameter tree; Step 6 is as follows: Step 61: Extract the input and output parameters of each interface in the generated flow chart and construct the parameter tree structure of input and output parameters; Step 62: Remove the redundant parameters that have been relied upon in the parameter tree according to the identified inter-interface dependency relationship; Step 63: Calculate semantic similarity for the remaining parameters, merge similar parameters, and process them uniformly in the process to reduce duplication of operations. Step 7: Optimize the execution efficiency of business processes by reducing redundant operations and parallelizing execution; Step 7 is as follows: Step 71: After generating the flowchart, continue to identify redundant operations in the process to reduce repeated calls; Step 72: Improve process execution efficiency by optimizing and merging similar parameters and parallelizing execution strategies.

Images