AI-based software function intelligent orchestration processing method and device, and electronic equipment

Abstract

The application relates to the technical field of data processing, in particular to an AI-based software function intelligent arrangement processing method and device and electronic equipment, the method comprising the following steps: constructing a function conflict identification model based on each function metadata and running constraint condition data to identify conflict functions; collecting resource occupation data of each distributed node in real time, and constructing a resource constraint model to generate real-time resource allocation constraint conditions; obtaining input data of each distributed node, listing a function path set, and then determining a function arrangement scheme in combination with the identification result of the conflict functions and the real-time resource allocation constraint conditions; setting path weights based on the function implementation paths of a monitoring period, and iteratively optimizing the function arrangement scheme of the next monitoring period; and adjusting the conflict functions according to the function implementation paths in the monitoring period. The application effectively improves the arrangement efficiency of software functions.

Description

Technical Field

[0001] This invention relates to the field of data processing technology, and in particular to an AI-based software function intelligent orchestration processing method, apparatus, and electronic device. Background Technology

[0002] In current distributed software systems, the orchestration of functional modules largely relies on manual configuration or static rule bases, lacking the ability to dynamically identify implicit conflicts such as protocol adaptability and component compatibility. When business requirements change or the system is expanded, service interruptions and response delays are easily caused by functional coupling conflicts and resource contention. Troubleshooting is time-consuming and labor-intensive, severely restricting system reliability and operational efficiency, and making it difficult to meet the needs of high-concurrency and rapid-iteration business scenarios.

[0003] Traditional resource scheduling strategies often rely on fixed thresholds or experience-based allocation, failing to integrate real-time load, historical paths, and multi-dimensional resource status for collaborative decision-making. This not only wastes computing resources and creates performance bottlenecks but also renders the system lacking in self-learning and environmental adaptability, resulting in insufficient flexibility when facing complex and dynamic scenarios. Therefore, there is an urgent need to build an intelligent orchestration technology system with perception, reasoning, and continuous optimization capabilities. Summary of the Invention

[0004] The purpose of this invention is to provide an AI-based intelligent software function orchestration processing method, apparatus, and electronic device to solve at least one of the problems existing in the prior art.

[0005] To achieve the above objectives, according to one aspect of this application, the present invention provides an AI-based intelligent software function orchestration processing method, comprising:

[0006] A functional conflict identification model is constructed based on the metadata of each function and the operational constraint data to identify conflicting functions;

[0007] Real-time collection of resource usage data from each distributed node and construction of a resource constraint model to generate real-time resource allocation constraints;

[0008] The system acquires input data from each distributed node and lists the set of functional paths. Then, it combines the identification results of conflicting functions with real-time resource allocation constraints to determine the functional orchestration scheme.

[0009] The path weights are set based on the functional implementation paths of the monitoring cycle, and the functional orchestration scheme for the next monitoring cycle is iteratively optimized.

[0010] Adjust conflicting functions based on the function implementation path within the monitoring period.

[0011] Optionally, calculate the protocol compatibility f1(i,j) and the conflict ratio f2(i,j) between each functional element, and set the following:

[0012] f1(i,j)=Nco(i,j) / Nto(i,j);

[0013] f2(i,j)=[DN(i,j)+BN(i,j)] / ZJ(i,j);

[0014] In the formula, Nco(i,j) represents the number of compatible protocols between the i-th functional element and the j-th functional element, Nto(i,j) represents the total number of protocol types between the i-th functional element and the j-th functional element, DN(i,j) represents the number of exclusive components between the i-th functional element and the j-th functional element, BN(i,j) represents the number of completely incompatible components between the i-th functional element and the j-th functional element, and ZJ(i,j) represents the number of components used by the i-th functional element and the j-th functional element.

[0015] Optionally, the conflict risk value R(i,j) between functional elements is calculated based on the protocol compatibility degree f1(i,j) between each functional element and the conflict ratio f2(i,j) of dependent components, and R(i,j) is set as a1×[1-f1(i,j)]+a2×f2(i,j);

[0016] Set a conflict threshold Rth, and judge conflicting functions based on the conflict risk value R(i,j) between Rth and each functional element: when R(i,j) is greater than Rth, the i-th functional element and the j-th functional element are determined to be a conflicting functional pair; otherwise, the i-th functional element and the j-th functional element are determined to be a non-conflicting functional pair.

[0017] Optionally, a real-time available resource index S(k) for each distributed node is constructed using the resource usage data of each distributed node, and the following settings are made:

[0018] S(k)=w1×(1−CPU(k))+w2×(1−Mem(k))+w3×(1−Bw(k))+w4×(1−Store(k));

[0019] In the formula, CPU(k), Mem(k), Bw(k) and Store(k) represent the real-time CPU utilization, memory utilization, bandwidth utilization and storage utilization of the k-th node, respectively, and their values ​​are all in the range of [0,1]. w1, w2, w3 and w4 are the resource weights of CPU utilization, memory utilization, bandwidth utilization and storage utilization, respectively, and k is the digital intersection table of the distributed nodes.

[0020] Optionally, a set of resource constraints can be established based on the factual available resource indices of each distributed node and the functional data of each node:

[0021] Condition 1: Ruse(i) is greater than or equal to Rmin(i);

[0022] Condition 2: Less than or equal to Ra(k) × S(k);

[0023] Condition 3: Ruse(i) is less than or equal to Rmax(i);

[0024] Where Ruse(i) represents the actual resource usage of the i-th functional element, Rmin(i) is the minimum operating resource requirement of the i-th functional element, Rmax(i) is the maximum operating resource requirement of the i-th functional element, and Ra(k) is the total available resources of the k-th distributed node.

[0025] Optionally, input data from each distributed node can be acquired in real time; the input data includes business request types and business requirement data.

[0026] The set of functional paths is listed based on the input data of each distributed node, and the set of functional paths is filtered according to the identification results of conflicting functions.

[0027] The function orchestration scheme is determined based on the selected set of function paths and real-time resource allocation constraints;

[0028] The input and output data formats of each functional element are matched with the input data, and the functional path set P is enumerated based on the matching results. P = {P1, P2... PM}, where P1, P2, and PM are all functional paths that are successfully matched with the input data.

[0029] Based on the identification results of conflicting functions, filter each functional path in the functional path set P: delete functional paths that contain conflicting function pairs within the same functional path;

[0030] The filtered set of functional paths is taken as the set of feasible functional paths P'.

[0031] Optionally, the distributed node corresponding to the input data is selected as the first candidate node, and the remaining distributed nodes are sorted in descending order according to the available resource index S(k) of each distributed node to obtain the candidate node table.

[0032] Verify the compatibility status of each functional path in the feasible functional path set P' with the candidate node table one by one: when all functional elements in the y-th functional path satisfy the first candidate node, the first candidate node is used as the adapting node for the y-th functional path; when only some functional elements in the y-th functional path can run within the first candidate node, the remaining functional element paths of the y-th functional path are allocated using the candidate node table.

[0033] Optionally, the function implementation path within the monitoring period is obtained and marked in the feasible function path set P'. If the function implementation path does not belong to the feasible function path set P', the function implementation path is added to the feasible function path set P' of the next monitoring period.

[0034] The number of times each functional path is marked, y(n), in the set of feasible functional paths is counted, and the path weight, w(y), of each functional path is calculated. w(y) is set to y(n) / ZN, where ZN is the number of functional paths generated within the monitoring period.

[0035] The path weights of each functional path are sorted in descending order, and the top three functional paths in the sorting result are used as pre-allocated resource paths.

[0036] According to another aspect of this application, an AI-based software function intelligent orchestration processing device is provided, comprising:

[0037] The conflict identification unit is used to build a functional conflict identification model based on the metadata of each function and the running constraint data in order to identify conflicting functions;

[0038] The constraint construction unit is used to collect resource usage data of each distributed node in real time and build a resource constraint model to generate real-time resource allocation constraints.

[0039] The orchestration scheme generation unit is used to obtain input data from each distributed node, list the set of functional paths, and then determine the functional orchestration scheme by combining the identification results of conflicting functions and real-time resource allocation constraints.

[0040] The iterative optimization unit is used to set path weights for the function implementation paths based on the monitoring cycle, and to iteratively optimize the function orchestration scheme for the next monitoring cycle.

[0041] The real-time adjustment unit is used to adjust conflicting functions based on the function implementation path within the monitoring period.

[0042] According to another aspect of this application, an electronic device is provided, comprising:

[0043] One or more processors;

[0044] Storage device for storing one or more programs;

[0045] When the one or more programs are executed by the one or more processors, the one or more processors implement the AI-based intelligent orchestration processing method for software functions.

[0046] Compared with existing technologies, the beneficial effects of this invention are as follows: By organically integrating five mechanisms—precise conflict identification, dynamic resource constraints, intelligent path orchestration, historical weight optimization, and runtime self-correction—an intelligent collaborative system with a closed loop of perception, decision-making, and optimization is constructed. This significantly improves overall system stability and resource utilization efficiency, effectively avoids functional conflicts and resource contention, and reduces manual intervention and maintenance costs. The system possesses continuous learning and environmental adaptation capabilities, dynamically responding to complex and ever-changing business needs, greatly enhancing service reliability and execution agility. It provides solid technical support for the high availability, high efficiency, and intelligent operation of distributed software systems, driving the evolution of operation and maintenance models towards autonomous evolution. Attached Figure Description

[0047] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0048] Figure 1 This is a flowchart illustrating the AI-based intelligent orchestration and processing method for software functions in this embodiment.

[0049] Figure 2 This is a flowchart illustrating the method for generating the functional orchestration scheme in this embodiment.

[0050] Figure 3 This is a schematic diagram of the structure of the AI-based intelligent software function orchestration processing device provided in this embodiment.

[0051] Figure 4 This is a schematic diagram of the structure of the electronic device provided in this embodiment. Detailed Implementation

[0052] To more clearly illustrate the present invention, the following description, in conjunction with preferred embodiments and accompanying drawings, further explains the invention. Similar components in the drawings are indicated by the same reference numerals. Those skilled in the art should understand that the specific description below is illustrative rather than restrictive and should not be construed as limiting the scope of protection of the present invention.

[0053] It should be noted that although the terms first, second, third, etc., may be used in the embodiments of this application for description, these descriptions should not be limited to these terms. These terms are only used to distinguish the descriptions. For example, without departing from the scope of the embodiments of this application, first can also be referred to as second, and similarly, second can also be referred to as first.

[0054] The acquisition, storage, use, and processing of data in this application all comply with the relevant provisions of national laws and regulations.

[0055] Specifically, the AI-based intelligent orchestration processing method for software functions described in this application is applied to software in industrial internet and complex distributed systems. In this application scenario, there are various heterogeneous, dynamic, and real-time functional components with different requirements. It is difficult for these functional components to cooperate efficiently, reliably, and adaptively. In this regard, traditional orchestration methods based on static workflows or fixed rules are difficult to adapt to complex scenarios such as sudden changes in equipment status, network jitter, dynamic adjustment of task priorities, and conflicts of global goals (such as optimal energy efficiency and lowest failure rate). The AI-based intelligent orchestration processing method, device, and electronic device provided by this invention are used to realize real-time intelligent orchestration of software functions based on AI, so as to achieve flexible adjustment and orchestration between functions, thereby adapting to real-time conditions and improving software work efficiency.

[0056] Specifically, before executing the AI-based software function intelligent orchestration processing method, device, and electronic device, this application needs to collect the required basic data, which includes:

[0057] Metadata and runtime constraints for each function;

[0058] Specifically, the metadata of each function includes the core function description, input and output data format, function identifier, and runtime dependent component number of each function element within the software; the runtime constraint data includes: minimum runtime resource threshold, maximum number of concurrent tasks, compatible operating system type, workload threshold, and fault recovery time requirement for each function element.

[0059] Applied to the aforementioned application scenarios and basic data, this application provides an AI-based intelligent orchestration and processing method for software functions, the flowchart of which can be found in the document. Figure 1 As shown, it includes:

[0060] Step S101: Construct a functional conflict identification model based on the metadata of each function and the running constraint data to identify conflicting functions;

[0061] Specifically, the implementation process of step S101 is as follows:

[0062] Calculate the protocol compatibility f1(i,j) and the conflict ratio f2(i,j) of dependent components between each functional element, and set:

[0063] f1(i,j)=Nco(i,j) / Nto(i,j);

[0064] f2(i,j)=[DN(i,j)+BN(i,j)] / ZJ(i,j);

[0065] In the formula, Nco(i,j) represents the number of compatible protocols between the i-th functional element and the j-th functional element, Nto(i,j) represents the total number of protocol types between the i-th functional element and the j-th functional element, DN(i,j) represents the number of exclusive components between the i-th functional element and the j-th functional element, BN(i,j) represents the number of completely incompatible components between the i-th functional element and the j-th functional element, and ZJ(i,j) represents the number of components used by the i-th functional element and the j-th functional element.

[0066] The conflict risk value R(i,j) between functional elements is calculated based on the protocol compatibility degree f1(i,j), the resource requirement overlap ratio f2(i,j), and the dependent component conflict ratio f2(i,j) between each functional element. R(i,j) is set as a1×[1-f1(i,j)]+a2×f2(i,j); where a1 and a2 are both weight exponents, and a1+a2=1.

[0067] Set a conflict threshold Rth, and judge conflicting functions based on the conflict risk value R(i,j) between Rth and each functional element: when R(i,j) is greater than Rth, the i-th functional element and the j-th functional element are determined to be a conflicting functional pair; otherwise, the i-th functional element and the j-th functional element are determined to be a non-conflicting functional pair.

[0068] Specifically, in this application, the conflict risk value is set to 0.6.

[0069] Specifically, by constructing a functional conflict identification model, potential conflicts between functional elements can be accurately identified in advance. This model comprehensively considers protocol adaptability and component compatibility, quantifies conflict risk values, and effectively avoids abnormal interruptions during functional execution. This significantly improves system stability, reduces resource waste and manual troubleshooting time, lays a reliable foundation for subsequent intelligent orchestration, and significantly improves the efficiency and reliability of software function collaboration.

[0070] It is understood that the completely incompatible components mentioned in this application refer to components where there is an underlying logic conflict between two components that prevents the two components from being loaded at the same time; the exclusive component refers to a component where only one functional element can be used at a time.

[0071] Please continue reading. Figure 1 As shown, the AI-based software-powered intelligent orchestration processing method further includes:

[0072] Step S102: Collect resource usage data of each distributed node in real time and construct a resource constraint model to generate real-time resource allocation constraints; the resource usage data of each distributed node includes: real-time CPU utilization, memory consumption, network bandwidth utilization, remaining storage capacity, computing power allocation status, and node load coefficient of each node.

[0073] Specifically, the implementation process of step S102 is as follows:

[0074] Construct the real-time available resource index S(k) for each distributed node based on its resource usage data, and define:

[0075] S(k)=w1×(1−CPU(k))+w2×(1−Mem(k))+w3×(1−Bw(k))+w4×(1−Store(k));

[0076] In the formula, CPU(k), Mem(k), Bw(k) and Store(k) represent the real-time CPU utilization, memory utilization, bandwidth utilization and storage utilization of the k-th node, respectively, and the values ​​range from [0,1]. w1, w2, w3 and w4 are the resource weights of CPU utilization, memory utilization, bandwidth utilization and storage utilization, respectively, and k is the digital intersection table of the distributed nodes.

[0077] Based on the available resource indices of each distributed node and the functional data, a set of resource constraints is established:

[0078] Condition 1: Ruse(i) is greater than or equal to Rmin(i);

[0079] Condition 2: Less than or equal to Ra(k) × S(k);

[0080] Condition 3: Ruse(i) is less than or equal to Rmax(i);

[0081] Where Ruse(i,k) represents the actual resource usage of the i-th functional element in the k-th distributed node, N is the number of functional elements currently running in the k-th distributed node, Rmin(i) is the minimum resource requirement for the i-th functional element, Rmax(i) is the maximum resource requirement for the i-th functional element, and Ra(k) is the total available resources of the k-th distributed node.

[0082] Specifically, by collecting distributed node resource data in real time and constructing a resource constraint model, the system's resource status can be dynamically perceived. This model integrates multi-dimensional indicators such as CPU, memory, bandwidth, and storage to generate precise resource allocation constraints. This makes resource allocation more rational and efficient, avoiding resource contention and overload issues, improving overall resource utilization, while ensuring the performance requirements of each functional element. It achieves refined resource management and dynamic optimization configuration, thereby improving system operating efficiency.

[0083] Please continue reading. Figure 1 As shown, the AI-based intelligent software function orchestration processing method further includes:

[0084] Step S103: Obtain the input data of each distributed node and list the set of functional paths. Then, combine the identification results of conflicting functions with the real-time resource allocation constraints to determine the functional orchestration scheme.

[0085] Please see Figure 2 The diagram shown is a flowchart illustrating the method for generating the functional orchestration scheme provided in this application, including:

[0086] Step S301: Obtain input data from each distributed node in real time; the input data includes business request type and business requirement data.

[0087] Step S302: List the set of functional paths based on the input data of each distributed node, and filter the set of functional paths according to the identification results of conflicting functions;

[0088] Step S303: Determine the function orchestration scheme based on the filtered set of function paths and real-time resource allocation constraints.

[0089] Specifically, in step S301, various types of data can be collected through distributed nodes and API interfaces. The specific process is a technical means well known to those skilled in the art and will not be described in detail in this application.

[0090] The implementation process of step S302 is as follows:

[0091] The input and output data formats of each functional element are matched with the input data, and the functional path set P is enumerated based on the matching results. P = {P1, P2... PM}, where P1, P2, and PM are all functional paths that are successfully matched with the input data.

[0092] Based on the identification results of conflicting functions, filter each functional path in the functional path set P: delete functional paths that contain conflicting function pairs within the same functional path;

[0093] The filtered set of functional paths is taken as the set of feasible functional paths P'.

[0094] It is worth noting that the functional path described in this application is an ordered set of multiple functional elements. Taking P1 as an example, P1={F(1,1),F(1,2)...F(1,n)}, F(1,1) represents the first functional element of the first functional path, F(1,2) represents the second functional element of the first functional path, and F(1,n) represents the nth functional element of the first functional path.

[0095] Specifically, in step S303, the process of determining the functional orchestration scheme based on the set of real-time resource allocation constraints is as follows:

[0096] The distributed nodes corresponding to the input data are used as the first candidate nodes, and the remaining distributed nodes are sorted in descending order according to the available resource index S(k) of each distributed node to obtain the candidate node table.

[0097] Verify the compatibility status of each functional path in the feasible functional path set P' with the candidate node table, and allocate resources for each functional path: when all functional elements in the y-th functional path satisfy the first candidate node, the first candidate node is used as the adapting node for the y-th functional path; when only some functional elements in the y-th functional path can run within the first candidate node, the remaining functional element paths of the y-th functional path are allocated using the candidate node table.

[0098] The resource allocation results of each functional path in the set of feasible functional paths are used as the functional orchestration scheme, and then output to the user.

[0099] It is worth noting that the judgment condition of "all functional elements in the y-th functional path satisfy the first candidate node" in this application is: when each functional element in the y-th functional path runs in the first candidate node, whether all functional elements can satisfy the resource constraint condition set of the first candidate node. Only when it is satisfied is it determined that "all functional elements in the y-th functional path satisfy the first candidate node". Similarly, the process of "allocating the remaining functional element paths of the y-th functional path" in "only some functional elements in the y-th functional path can run in the first candidate node, and allocating the remaining functional element paths of the y-th functional path in the candidate node table" also needs to satisfy the resource constraint condition set of each distributed node in the candidate node table. The specific process is not described in this application. Those skilled in the art can implement the judgment process of the resource constraint condition through a computer program.

[0100] Specifically, by combining input data, conflict identification results, and resource constraints, a functional orchestration scheme is determined, achieving intelligent path selection. This step selects the optimal execution sequence from numerous feasible paths, ensuring conflict-free functions and compliance with resource limitations. This significantly improves orchestration accuracy and efficiency, avoids the subjectivity and inefficiency of manual configuration, enables the system to quickly respond to diverse business needs, improves the collaborative execution efficiency of software functions, and enhances the system's adaptability to complex scenarios.

[0101] Please continue reading. Figure 1 As shown, the AI-based intelligent software function orchestration processing method further includes:

[0102] Step S104: Set path weights for the function implementation path based on the monitoring cycle, and iteratively optimize the function arrangement scheme for the next monitoring cycle. This application does not specifically limit the duration of the monitoring cycle; those skilled in the art can freely set it, as long as it meets the requirements of the monitoring cycle value. In this application, the monitoring cycle value is set to 5 minutes. The function implementation path is the function operation path of the actual input data within the monitoring cycle; its data structure is the same as the function path, and its collection method can be achieved through the operation logs of the distributed system.

[0103] Specifically, the implementation process of step S104 is as follows:

[0104] Obtain the functional implementation path within the monitoring period and mark the functional implementation path in the feasible functional path set P'. If the functional implementation path does not belong to the feasible functional path set P', add the functional implementation path to the feasible functional path set P' of the next monitoring period.

[0105] The number of times each functional path is marked, y(n), in the set of feasible functional paths is counted, and the path weight, w(y), of each functional path is calculated. w(y) is set as y(n) / ZN, where ZN is the number of functional paths generated within the monitoring period.

[0106] The path weights of each functional path are sorted in descending order, and the top three functional paths in the sorting result are used as pre-allocated resource paths.

[0107] Specifically, after selecting the pre-allocated resource path in this application, the resources of the distributed nodes corresponding to the pre-allocated resource path need to be pre-allocated.

[0108] Specifically, path weights are set and iteratively optimized based on the functional implementation paths within the monitoring period, endowing the system with self-learning capabilities. This mechanism identifies frequently used paths, pre-allocates resources, and reduces response latency. This weight adjustment based on historical data enables the system to continuously optimize its behavior, improve resource allocation efficiency, reduce decision-making time overhead, make functional orchestration more aligned with actual business needs, enhance system adaptability and intelligence, and achieve continuous performance improvement.

[0109] Please continue reading. Figure 1 As shown, the AI-based software-powered intelligent orchestration processing method further includes:

[0110] Step S105: Adjust conflicting functions according to the function implementation path within the monitoring period.

[0111] Specifically, the implementation process of step S105 is as follows:

[0112] If there are conflicting function pairs in the function implementation path within the monitoring period, delete the conflicting function pair; otherwise, do not adjust the conflicting functions.

[0113] Specifically, the system dynamically adjusts conflicting functions based on the functional implementation path within the monitoring period, enabling self-correction. This mechanism can identify conflicting function pairs that occur during actual operation and update the conflict identification model in real time. This allows the system to adapt to dynamically changing operating environments and functional requirements, avoids deviations between preset rules and actual conditions, improves system robustness and stability, ensures long-term operational reliability, reduces maintenance costs, forms a closed-loop optimization mechanism, and gives the system the characteristic of continuous evolution.

[0114] Please see Figure 3 As shown, it is a schematic diagram of the structure of the AI-based software function scheduling processing device provided in this application, including:

[0115] The conflict identification unit is used to build a functional conflict identification model based on the metadata of each function and the running constraint data in order to identify conflicting functions;

[0116] The constraint construction unit is used to collect resource usage data of each distributed node in real time and build a resource constraint model to generate real-time resource allocation constraints.

[0117] The orchestration scheme generation unit is used to obtain input data from each distributed node, list the set of functional paths, and then determine the functional orchestration scheme by combining the identification results of conflicting functions and real-time resource allocation constraints.

[0118] The iterative optimization unit is used to set path weights for the function implementation paths based on the monitoring cycle, and to iteratively optimize the function orchestration scheme for the next monitoring cycle.

[0119] The real-time adjustment unit is used to adjust conflicting functions based on the function implementation path within the monitoring period.

[0120] The AI-based intelligent software function orchestration processing device provided in this application embodiment can execute the AI-based intelligent software function orchestration processing method provided in any embodiment of this application, and has the corresponding functional modules and beneficial effects of the execution method.

[0121] From a hardware perspective, to realize the AI-based intelligent software function orchestration processing method in a computer, this application also provides an electronic device; please refer to [link to relevant documentation]. Figure 4 As shown, it is a schematic diagram of the structure of the electronic device described in this application, including:

[0122] The system comprises a processor 1, a memory 2, a communication interface 3, and a bus 4; wherein the processor 1 and the memory 2, and the memory 2 and the communication interface 3, transmit data via the bus 4; the processor is used to process data in the memory and generate commands, the memory is used to store data, the communication interface is used to receive and send data, and the bus is used to realize data transmission between the processor, the memory, and the communication interface.

[0123] In this embodiment, the AI-based intelligent software function orchestration processing method can be implemented as a runnable computer program. When the computer program is loaded into the processor or into the memory and processed by the processor via the bus, one or more steps of the AI-based intelligent software function orchestration processing can be executed.

[0124] This embodiment also provides a computer-readable storage medium for storing the computer-executable instructions. The computer-readable storage medium is a tangible physical storage medium that can store the computer program and various types of data used in the program. The physical storage medium includes, but is not limited to, existing physical storage media or combinations thereof, such as random access memory, read-only memory, optical disk, and hard disk.

[0125] The technical solution of the present invention has been described above with reference to the preferred embodiments shown in the accompanying drawings. However, it will be readily understood by those skilled in the art that the scope of protection of the present invention is obviously not limited to these specific embodiments. Without departing from the principles of the present invention, those skilled in the art can make equivalent changes or substitutions to the relevant technical features, and the technical solutions after these changes or substitutions will all fall within the scope of protection of the present invention.

Claims

1. A software function intelligent orchestration and processing method based on AI, characterized in that, include: A functional conflict identification model is constructed based on the metadata of each function and the operational constraint data to identify conflicting functions; Real-time collection of resource usage data from each distributed node and construction of a resource constraint model to generate real-time resource allocation constraints; The system acquires input data from each distributed node and lists the set of functional paths. Then, it combines the identification results of conflicting functions with real-time resource allocation constraints to determine the functional orchestration scheme. The function implementation path is weighted based on the monitoring cycle, and the function orchestration scheme for the next monitoring cycle is iteratively optimized. Adjust conflicting functions based on the function implementation path within the monitoring period.

2. The AI-based intelligent software function orchestration and processing method according to claim 1, characterized in that, Calculate the protocol compatibility f1(i,j) and the conflict ratio f2(i,j) of dependent components between each functional element, and set: f1(i,j)=Nco(i,j) / Nto(i,j); f2(i,j)=[DN(i,j)+BN(i,j)] / ZJ(i,j); In the formula, Nco(i,j) represents the number of compatible protocols between the i-th functional element and the j-th functional element, Nto(i,j) represents the total number of protocol types between the i-th functional element and the j-th functional element, DN(i,j) represents the number of exclusive components between the i-th functional element and the j-th functional element, BN(i,j) represents the number of completely incompatible components between the i-th functional element and the j-th functional element, and ZJ(i,j) represents the number of components used by the i-th functional element and the j-th functional element.

3. The AI-based intelligent software function orchestration method according to claim 2, characterized in that, The conflict risk value R(i,j) between functional elements is calculated based on the protocol compatibility degree f1(i,j) between each functional element and the conflict ratio f2(i,j) of dependent components. R(i,j) is set as a1 × [1 - f1(i,j)] + a2 × f2(i,j). Set a conflict threshold Rth, and judge conflicting functions based on the conflict risk value R(i,j) between Rth and each functional element: when R(i,j) is greater than Rth, the i-th functional element and the j-th functional element are determined to be a conflicting functional pair; otherwise, the i-th functional element and the j-th functional element are determined to be a non-conflicting functional pair.

4. The AI-based intelligent software function orchestration and processing method according to claim 3, characterized in that, Construct the real-time available resource index S(k) for each distributed node based on its resource usage data, and define: S(k)=w1×(1−CPU(k))+w2×(1−Mem(k))+w3×(1−Bw(k))+w4×(1−Store(k)); In the formula, CPU(k), Mem(k), Bw(k) and Store(k) represent the real-time CPU utilization, memory utilization, bandwidth utilization and storage utilization of the k-th node, respectively, and their values ​​are all in the range of [0,1]. w1, w2, w3 and w4 are the resource weights of CPU utilization, memory utilization, bandwidth utilization and storage utilization, respectively, and k is the digital intersection table of the distributed nodes.

5. The AI-based intelligent software function orchestration and processing method according to claim 4, characterized in that, Based on the available resource indices of each distributed node and the functional data, a set of resource constraints is established: Condition 1: Ruse(i) is greater than or equal to Rmin(i); Condition 2: Less than or equal to Ra(k) × S(k); Condition 3: Ruse(i) is less than or equal to Rmax(i); Where Ruse(i) represents the actual resource usage of the i-th functional element, Rmin(i) is the minimum operating resource requirement of the i-th functional element, Rmax(i) is the maximum operating resource requirement of the i-th functional element, and Ra(k) is the total available resources of the k-th distributed node.

6. The AI-based intelligent software function orchestration processing method according to claim 5, characterized in that, The system acquires input data from each distributed node in real time; the input data includes business request types and business requirement data. The set of functional paths is listed based on the input data of each distributed node, and the set of functional paths is filtered according to the identification results of conflicting functions. The function orchestration scheme is determined based on the selected set of function paths and real-time resource allocation constraints; The input and output data formats of each functional element are matched with the input data, and the functional path set P is enumerated based on the matching results. P = {P1, P2... PM}, where P1, P2, and PM are all functional paths that are successfully matched with the input data. Based on the identification results of conflicting functions, filter each functional path in the functional path set P: delete functional paths that contain conflicting function pairs within the same functional path; The filtered set of functional paths is taken as the set of feasible functional paths P'.

7. The AI-based intelligent software function orchestration and processing method according to claim 6, characterized in that, The distributed nodes corresponding to the input data are used as the first candidate nodes, and the remaining distributed nodes are sorted in descending order according to the available resource index S(k) of each distributed node to obtain the candidate node table. Verify the compatibility status of each functional path in the feasible functional path set P' with the candidate node table one by one: when all functional elements in the y-th functional path satisfy the first candidate node, the first candidate node is used as the adapting node for the y-th functional path; when only some functional elements in the y-th functional path can run within the first candidate node, the remaining functional element paths of the y-th functional path are allocated using the candidate node table.

8. The AI-based intelligent software function orchestration method according to claim 7, characterized in that, Obtain the functional implementation path within the monitoring period and mark the functional implementation path in the feasible functional path set P'. If the functional implementation path does not belong to the feasible functional path set P', add the functional implementation path to the feasible functional path set P' of the next monitoring period. The number of times each functional path is marked, y(n), in the set of feasible functional paths is counted, and the path weight, w(y), of each functional path is calculated. w(y) is set as y(n) / ZN, where ZN is the number of functional paths generated within the monitoring period. The path weights of each functional path are sorted in descending order, and the top three functional paths in the sorting result are used as pre-allocated resource paths.

9. An AI-based intelligent software function orchestration processing device, applied to the AI-based intelligent software function orchestration processing method as described in any one of claims 1-8, characterized in that, include: The conflict identification unit is used to build a functional conflict identification model based on the metadata of each function and the running constraint data in order to identify conflicting functions; The constraint construction unit is used to collect resource usage data of each distributed node in real time and build a resource constraint model to generate real-time resource allocation constraints. The orchestration scheme generation unit is used to obtain input data from each distributed node, list the set of functional paths, and then determine the functional orchestration scheme by combining the identification results of conflicting functions and real-time resource allocation constraints. The iterative optimization unit is used to set path weights for the function implementation paths based on the monitoring cycle, and to iteratively optimize the function orchestration scheme for the next monitoring cycle. The real-time adjustment unit is used to adjust conflicting functions based on the function implementation path within the monitoring period.

10. An electronic device, characterized in that, The electronic device includes: One or more processors; Storage device for storing one or more programs; When the one or more programs are executed by the one or more processors, the one or more processors implement the AI-based intelligent orchestration processing method for software functions as described in any one of claims 1-8.

Images