Cloud native application intention driven intelligent arrangement system based on large language model

Abstract

The invention relates to the field of artificial intelligence cloud computing, in particular to a cloud native application intention driven intelligent arrangement system based on a large language model. The intention analysis module is used for receiving input data and carrying out feature extraction and vectorization decomposition; outputting an intention vector representation; the strategy planning module is used for receiving the intention vector representation, generating a decision strategy through a multi-objective optimization algorithm and outputting an arrangement strategy; the arrangement execution module is used for receiving the arrangement strategy, analyzing the arrangement strategy through a feature mapping network, converting the arrangement strategy into an instruction set and outputting execution result data; the model training module is used for receiving execution result data and input data and generating a weight updating event when parameters change; and the autonomous learning module is used for receiving the weight updating event, carrying out neural network processing, generating an improved arrangement strategy and forming an adaptive learning mechanism. According to the method, the natural language intention is analyzed through the large language model, and the accuracy and robustness of large-scale arrangement are improved in combination with the data-driven decision.

Description

Technical Field

[0001] The present invention relates to the field of artificial intelligence cloud computing, and specifically to a cloud-native application intent-driven intelligent orchestration system based on a large language model. Background Art

[0002] In today's business and technology environment, enterprises are increasingly adopting cloud-native technologies to build and run their mission-critical applications to remain competitive in a rapidly changing market. Cloud-native is a software architecture and deployment methodology that leverages the advantages of cloud computing models. Its core goal is to achieve rapid application delivery, high scalability, and strong system resilience. It is typically built on technological pillars such as microservices, containers, and powerful container orchestration platforms. Furthermore, advances in artificial intelligence, particularly the emergence of large language models, are opening up new possibilities for automating complex IT operations.

[0003] Reinforcement learning agent frameworks that leverage large language models for task orchestration have emerged. For example, some advanced agent frameworks employ a modular design, including a task decomposition model, a tool selection model, and an operation model. When faced with a user query, the task decomposition model first decomposes it into preliminary subtasks. Subsequently, the tool selection model uses semantic search to match the most appropriate tool for each subtask in the tool library. If a sufficiently matching tool cannot be found for a subtask, the system recursively calls the task decomposition model to further refine the subtask until all steps are accurately matched with available tools.

[0004] While existing technologies have made progress in automating task planning and service orchestration using large language models, they still face significant shortcomings when applied to the complexities of real-world cloud-native environments. These systems treat the underlying cloud infrastructure as a limited "black box" with limited functionality. They lack direct awareness of, and control over, core primitives like Kubernetes. Consequently, there is a significant semantic gap between their service orchestration and the underlying, declarative operations required by cloud-native systems, making it difficult to effectively translate operational intent into precise infrastructure changes. Furthermore, their static, open-loop planning models are out of sync with the dynamic, event-driven, and stateful nature of cloud-native environments, making them incapable of achieving continuous, state-aware closed-loop control.

[0005] To summarize, a new type of intelligent system is needed that can directly and intelligently convert human operational intent into state-aware, optimized automated operations on the cloud-native control plane, thereby truly bridging the gap between service-level orchestration and infrastructure-level orchestration.

[0006] To this end, a cloud-native application intent-driven intelligent orchestration system based on a large language model is proposed. Summary of the Invention

[0007] The purpose of the present invention is to provide a cloud-native application intent-driven intelligent orchestration system based on a large language model to solve the problems raised in the above background technology.

[0008] To achieve the above objectives, the present invention provides the following technical solution: a cloud-native application intent-driven intelligent orchestration system based on a large language model, comprising: The intent parsing module receives input data, extracts features, and performs vectorized decomposition using a large language model. It encodes intent features using a knowledge graph, reduces training bias, and outputs an intent vector representation. The strategy planning module receives the intent vector representation, generates a decision strategy through a multi-objective optimization algorithm, calls the prediction model for model inference, and obtains a strategy evaluation vector. It then optimizes the strategy based on the weight parameters and outputs the orchestration strategy. The orchestration execution module receives the orchestration strategy, performs resource analysis through the feature mapping network, obtains computing parameters, and converts the orchestration strategy into a set of instructions. It completes state transitions through the reinforcement learning agent and outputs execution result data. The model training module receives execution result data and input data, converts user input into verification logic through a large language model, performs neural network training, and generates weight update events when network parameters change; The autonomous learning module receives weight update events, performs neural network processing on the data, generates improved orchestration strategies, and sends them back to the orchestration execution module to form an adaptive learning mechanism.

[0009] Preferably, the specific implementation process of performing feature extraction and vector decomposition includes: The input data is fed into a large language model fine-tuned in the operation and maintenance domain; deep feature encoding is performed through the multi-head self-attention mechanism of the Transformer neural network architecture; the word embedding neural network space of the pre-trained model is used to obtain a parameter set containing core tasks, performance goals, cost constraints, and priorities; cloud native resource features and operation type vectors are extracted through the expert system rule engine; a probabilistic inference algorithm is used to calculate the dependency parameters between components; the extracted deep feature codes, parameter sets, cloud native resource feature vectors, and dependency parameters are organized into structured vectors through fully connected neural network encoding.

[0010] Preferably, the specific implementation process of outputting the intention vector representation includes: Receive structured vectors; extract key features and entity embedding vectors through the knowledge graph reasoning network; use fuzzy logic reasoning algorithms to perform vector calculations in dynamic knowledge structures; learn vector representations of cloud native resource nodes through decision tree learning algorithms; obtain the current configuration parameters, operating status vectors, and dependency matrices of resources; align user input with system data through multimodal fusion neural networks; and generate intent vector representations.

[0011] Preferably, the specific implementation process of performing model reasoning includes: Receive the intent vector representation, generate multiple candidate decision strategy vectors through the generative reasoning ability and combinatorial generalization ability of the large language model; call the random forest-based prediction model for each candidate decision strategy vector; perform strategy optimization analysis through a genetic algorithm; obtain prediction data on performance indicators, cost overhead and reliability; and generate a strategy evaluation vector containing the prediction data through an ensemble learning method.

[0012] Preferably, the implementation process of the output arrangement strategy includes: Receive the strategy evaluation vector, extract the prediction results of each decision strategy in different dimensions through a convolutional neural network; perform multi-objective optimization calculations based on the weight parameters defined in the intent vector representation to obtain a scoring vector; and use an intelligent strategy selection algorithm to select a strategy that meets the user's overall input as the orchestration strategy.

[0013] Preferably, the process of converting the orchestration strategy into an instruction set includes: The orchestration strategy is received and deep feature extraction is performed through a generative neural network. A probabilistic graphical model is used to perform vector calculations on each orchestration strategy step to obtain computational parameters for resources containing complete identifiers and existing labels. The code generation capabilities and template matching algorithms of a large language model are used to convert abstract strategies into executable instructions. A variational autoencoder is used to generate an instruction set containing cloud-native configurations.

[0014] Preferably, the specific implementation process of outputting the execution result data includes: Receives a set of instructions and establishes a connection with the cloud-native control plane through a reinforcement learning agent. Uses an intelligent scheduling algorithm to apply each execution instruction in sequence according to the execution sequence defined in the instruction set. Records the execution results and status information of each instruction application through a deep learning network. Uses a timing analysis neural network to record the actual impact of configuration changes on the infrastructure status. Generates execution result data containing execution status, information, and resource change details through an attention mechanism.

[0015] Preferably, the specific implementation process of generating the weight update event includes: The execution result data and the input data are received simultaneously, and the performance goals and constraints in the user input are assisted in being converted into verification logic based on preset rules through a large language model; a continuous learning mechanism is established, and a reinforcement learning algorithm is used to continuously run training inference; a key indicator vector reflecting the current system status is obtained through a monitoring data processing neural network; a statistical learning algorithm is used to perform numerical calculations on the actual status indicators and the target vector; and a weight update event is generated based on preset trigger conditions.

[0016] Preferably, the specific implementation process of forming the adaptive learning mechanism includes: Receive the weight update event, extract detailed parameter information and context data through the graph neural network; use the large language model to perform inference calculation and correlation analysis on the data, and mine high-correlation influencing factors; use the neural network algorithm to calculate the influencing factors and correlation paths that lead to changes in system parameters; use the generative neural network to autonomously learn and generate improved orchestration strategies based on the inference calculation conclusions; send the generated improved orchestration strategies back to the orchestration execution module for re-learning and implementation, forming an adaptive learning mechanism.

[0017] Compared with the prior art, the present invention has the following beneficial effects: 1. In terms of intelligence, the present invention uses a large language model to parse natural language intent, combined with data-driven decision-making, to promote the transformation of the orchestration paradigm from "imperative" to "intent-driven", thereby improving the level of automation in decision-making. And through a closed-loop adaptive learning mechanism, the internal policy model is optimized based on real execution result data, prompting the strategy to evolve from static configuration to dynamic adaptation. In addition, through a multi-objective optimization algorithm, multiple related goals are calculated to provide a data-driven basis for operation and maintenance decisions. Finally, by abstracting the cloud-native environment into a resource dependency graph and combining it with simulation and deduction, information distortion and error accumulation in traditional processes are reduced, and the accuracy and robustness of large-scale orchestration are improved.

[0018] 2. In terms of the economic effect of reduced operation and maintenance costs, the present invention brings corresponding economic benefits by lowering technical barriers and improving resource efficiency. First, the use of natural language intent input as an aid to the writing of traditional YAML configuration files reduces the dependence on senior technical personnel. Second, the automated policy generation, execution and verification process can reduce part of the workload of operation and maintenance personnel in the manual configuration link. Third, intelligent resource recommendation and dynamic scheduling can be managed based on actual load, which has a positive effect on reducing cloud resource costs. In addition, its performance drift detection and predictive maintenance capabilities provide technical means for identifying potential problems in advance, which helps to reduce the related costs caused by fault handling.

[0019] 3. In terms of the application effect of improving user experience, the present invention improves user experience through designs that simplify operations, improve efficiency, and enhance reliability, allowing users to focus more on business goals rather than underlying technical implementations, thereby reducing operational barriers and learning costs. First, the automated process from intent input to policy execution, its automated nature improves end-to-end efficiency from intent to deployment. In addition, the integration of the built-in multi-layer verification pipeline and the policy engine helps to ensure the correctness and security of the generated configuration, reducing deployment failures due to configuration errors. Ultimately, the system's adaptive learning capabilities can learn the user's operational preferences, helping to provide more demand-oriented services in long-term use, thereby improving the user's overall application experience. BRIEF DESCRIPTION OF THE DRAWINGS

[0020] Figure 1 This is a structural diagram of a cloud-native application intent-driven intelligent orchestration system based on a large language model proposed in an embodiment of the present invention; Figure 2 This is a closed-loop autonomous learning flow chart proposed in the embodiment of the present invention; Figure 3 This is a flowchart of the intent parsing proposed in the embodiment of the present invention application. DETAILED DESCRIPTION

[0021] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present invention.

[0022] See also Figure 1-Figure 3 The present invention provides a cloud-native application intent-driven intelligent orchestration system based on a large language model. The specific modules are as follows: The intent parsing module receives input data, extracts features, and performs vectorized decomposition using a large language model. It encodes intent features using a knowledge graph, reduces training bias, and outputs an intent vector representation. The strategy planning module receives the intent vector representation, generates a decision strategy through a multi-objective optimization algorithm, calls the prediction model for model inference, and obtains a strategy evaluation vector. It then optimizes the strategy based on the weight parameters and outputs the orchestration strategy. The orchestration execution module receives the orchestration strategy, performs resource analysis through the feature mapping network, obtains computing parameters, and converts the orchestration strategy into a set of instructions. It completes state transitions through the reinforcement learning agent and outputs execution result data. The model training module receives execution result data and input data, converts user input into verification logic through a large language model, performs neural network training, and generates weight update events when network parameters change; The autonomous learning module receives weight update events, performs neural network processing on the data, generates improved orchestration strategies, and sends them back to the orchestration execution module to form an adaptive learning mechanism.

[0023] The technical solution of the present invention is further described in detail below with reference to specific embodiments.

[0024] Example 1 The embodiment of the present application discloses a cloud native application intention-driven intelligent orchestration system based on a large language model. When user A needs to deploy an application, this system is used for intelligent orchestration. Figure 1 The specific modules proposed in the present invention include: intention parsing module: receiving input data, performing feature extraction and vectorized decomposition; realizing intent feature encoding, and outputting intent vector representation; strategy planning module: receiving intent vector representation, generating decision strategies through multi-objective optimization algorithm, performing model reasoning and strategy optimization, and outputting orchestration strategies; orchestration execution module: receiving orchestration strategies, analyzing them through feature mapping network, converting them into instruction sets, and outputting execution result data; model training module: receiving execution result data and input data, performing neural network training, and generating weight update events when parameters change; autonomous learning module: receiving weight update events, performing neural network processing, generating improved orchestration strategies, and sending them back to the orchestration execution module to form an adaptive learning mechanism.

[0025] Furthermore, the input data is received and feature extraction and vectorization decomposition are performed through the large language model; corresponding to the above-mentioned intent parsing module, see Figure 3 ; The specific implementation process includes: The system receives user natural language input data containing the deployment intention, performance requirements, and operation and maintenance requirements of cloud native applications. For example, the user inputs "Deploy microservice applications to a production environment, requiring high availability, automatic scaling, and cost control within 10,000 yuan per month." The system cleans and formats the input data, and at the same time loads a large language model that is fine-tuned specifically for the cloud native operation and maintenance field. In this embodiment, the open source large language model LLaMA-2 7B based on the Transformer architecture is selected as the basic model. First, a high-quality fine-tuning dataset containing approximately 100,000 data pairs is constructed. The dataset consists of two parts: the first part is the Kubernetes-related YAML configuration files and their corresponding functional description comments collected from the public code repository; the second part is high-quality operation and maintenance problems and authoritative solutions compiled from the public cloud native technology Q&A community. Subsequently, the dataset is cleaned and processed into a unified format to adapt to the instruction fine-tuning task, and the low-rank adaptive technology is used to fine-tune the parameters of the basic model for high efficiency. During the fine-tuning process, the rank is set to 8, the alpha scaling factor is 16, the AdamW optimizer is used, and the learning rate is set to 2e -5 .

[0026] The preprocessed input data is fed into the Transformer neural network architecture, where a multi-head self-attention mechanism is used to perform deep feature encoding on the text content, capturing semantic relationships at different levels within the input text. For example, the first attention head identifies the core concept of "microservice application," the second focuses on the performance requirement of "high availability," and the third analyzes the constraints of "cost control." The deep feature encoding results are then mapped into a high-dimensional vector space using the word embedding neural network space of the pretrained model, extracting a parameter set that includes the core tasks, performance objectives, cost constraints, and priorities.

[0027] The system obtains resource configuration information in the cloud native environment through the expert system rule engine, including infrastructure status such as computing node specifications, storage capacity distribution, and network topology, and converts this information into structured resource feature vectors based on the predefined cloud native knowledge rule base. By automatically discovering components as nodes and combining static, dynamic, and logical analysis to identify dependencies, the system constructs a probabilistic dependency graph. Each dependency edge in the graph is assigned an initial probability based on the data. Subsequently, when the state of any component changes, the probabilistic reasoning algorithm calculates its direct and indirect impact on the entire system through probability propagation, and finally generates dependency parameters. The system uses a fully connected neural network to uniformly encode and organize deep feature encoding, parameter sets, resource feature vectors, and dependency parameters. The knowledge graph reasoning network verifies the semantic consistency of the encoding process to generate a structured vector.

[0028] The integration of the semantic understanding capabilities of large language models and the domain knowledge of expert systems improves the depth and accuracy of intent feature extraction, generates information-rich and structured vector representations, and lays the data foundation for subsequent precise analysis.

[0029] Furthermore, the knowledge graph is used to encode the intent features, reduce the training bias, and output the intent vector representation; for the corresponding intent parsing module, see Figure 3 ; The specific implementation process includes: The system inputs structured vectors into the knowledge graph reasoning network, first defining the core schema of the knowledge graph. Node (entity) types include at least: "Application," "Service," "Deployment," "Database," "Middleware," "Node," and "PersistentVolume." Edge (relationship) types include at least: "dependsOn," "deploysOn," "connectsTo," "exposes," and "mounts." The knowledge graph data is constructed and updated by automated scripts that regularly parse Kubernetes YAML configuration files and HelmCharts in the company's internal code repository. This data is then extracted from official documentation on cloud native technologies and entities. In this embodiment, the knowledge graph reasoning network uses a graph convolutional network (GCN) model. This GCN model learns entity adjacency relationships within the knowledge graph, aggregating the features of each entity node with those of its neighbors. After multiple layers of convolutional iterations, it generates entity embeddings that incorporate neighborhood structure information. Each entity in the user's intent serves as a knowledge node, and the semantic relationships between entities serve as inference edges. For example, for the query "Configure a load balancer for the e-commerce platform's order service to ensure 100,000 concurrent requests during a promotional event," the inference network identifies key entities such as "e-commerce platform," "order service," and "load balancer" as knowledge nodes, and establishes semantic inference edges such as "Order service relies on load balancer" and "High concurrency during promotional events," forming a complete dynamic knowledge structure. The system then applies fuzzy logic inference algorithms to perform vector calculations within the dynamic knowledge structure, dynamically adjusting the importance weights of nodes and edges in the graph based on the uncertainties and real-time changes of cloud-native environments. For example, during a promotional event, the correlation between the "high concurrency" and "load balancing" nodes increases significantly.

[0030] After learning the vector representation of cloud-native resource nodes using a decision tree algorithm, the system constructs a decision tree model to process the topological relationships and attribute characteristics of compute nodes, storage resources, network components, and service instances. The decision tree algorithm performs classification learning based on resource attribute characteristics and updates the state vector of each resource node through a tree-structured reasoning path. The system obtains the current configuration parameters, state vector, and dependency matrix of the resource. Configuration parameters are obtained from an expert system rule base, including static information such as specification configuration, deployment parameters, and environmental variables. The state vector is collected from a monitoring system in real time, collecting dynamic indicator vectors such as CPU utilization and memory usage. The dependency matrix is ​​constructed by analyzing information such as service call chains and data flows using a probabilistic reasoning algorithm.

[0031] Through a multimodal fusion neural network, the user input and system data are aligned, and the attention mechanism is used to process the heterogeneous information of user text semantics and numerical data. The importance weights of different types of information are dynamically adjusted through cross-modal attention calculation to achieve feature mapping between modalities and ultimately generate an intent vector representation containing rich context.

[0032] By combining knowledge graphs and multimodal fusion, the user's abstract intent is associated with the system's real-time state. This approach ensures that the resulting intent vector representation not only reflects user needs but also incorporates the necessary system context, thereby enhancing the practical feasibility of subsequent strategic planning.

[0033] Furthermore, the intention vector representation is received, a decision strategy is generated through a multi-objective optimization algorithm, and the prediction model is called for model reasoning to obtain a strategy evaluation vector; this corresponds to the strategy planning module. The specific implementation process includes: The system parses and verifies the complete intent vector representation to ensure the complete availability of key information such as task objectives, constraints, and priority weights. It then activates the generative reasoning and combinatorial generalization capabilities of the large language model to generate multiple candidate decision strategy vectors. Based on its understanding of cloud-native domain knowledge, it designs multiple implementation paths for the same user intent, tailored to the specific scenario. For example, for the requirement of "improving system stability during promotional periods for online shopping websites," the large language model generates candidate strategies including: horizontal scaling, which distributes system load by increasing the number of service instances; vertical scaling, which enhances processing power by increasing the CPU and memory configuration of individual instances; and hybrid optimization, which combines technologies such as intelligent caching, database read-write splitting, and content delivery network acceleration to achieve comprehensive performance improvements. For each decision strategy, a random forest-based prediction model is invoked, which builds multiple decision trees in parallel for prediction. The performance prediction sub-model analyzes performance metrics such as response time, throughput, and resource utilization; the cost prediction sub-model assesses costs such as computing resources, storage space, and network bandwidth; and the reliability prediction sub-model focuses on reliability metrics such as system stability, fault tolerance, and recovery time.

[0034] The system uses genetic algorithms to represent the parameters of candidate strategies as individuals. It then uses fitness to evaluate the strategies' comprehensive performance in a multi-objective space. It then uses evolutionary operations such as selection, crossover, and mutation to perform global search and optimization within the strategy parameter space, exploring the robustness of candidate strategies under abnormal conditions such as traffic surges, node failures, and network delays. It also uses machine learning algorithms to predict the execution results of each strategy, including the expected indicator range, probability of achievement (confidence interval), and potential risk points, based on performance indicators, cost overhead, and reliability. Regression algorithms are used to analyze the changing trends of performance indicators after strategy implementation. In the cost dimension, regression algorithms are used to establish a cost prediction model and calculate the overall economic benefits of the strategies. In the reliability dimension, classification algorithms are used to assess the impact of strategies on the overall stability of the system.

[0035] Finally, the system uses an integrated learning method to comprehensively analyze the results of the random forest prediction model, performs high-level abstraction and fusion through a meta-learner, and dynamically assigns weights to each prediction model. It intelligently adjusts the importance of prediction results in different dimensions based on the current scenario characteristics and user preferences, and generates a strategy evaluation vector that includes the specific values ​​of each prediction indicator, confidence interval assessment, and risk analysis results.

[0036] By combining generative and predictive models, we systematically explore and evaluate multiple candidate decisions, and use optimization analysis to predict the potential execution results of each strategy, thereby providing data support for the selection of well-considered and predictable solutions.

[0037] Furthermore, the weight parameters are combined to optimize the strategy and output the orchestration strategy; corresponding to the strategy planning module; the specific implementation process includes: The system receives a strategy evaluation vector and uses a convolutional neural network to extract the prediction results of each decision strategy in different dimensions. This convolutional neural network adopts a multi-channel architecture and simultaneously processes prediction data in different dimensions such as performance, cost, and reliability. The convolution operation extracts the feature correlations between these dimensions. For example, when processing the strategy evaluation of "online education platforms coping with peak traffic during live course broadcasts," the convolutional neural network identified: Strategy A excels in performance improvement but has a higher cost; Strategy B is more balanced in cost-effectiveness but has a slightly slower response speed; Strategy C has an advantage in reliability but is more complex to implement. Through feature map analysis, it extracts the deep feature representations of each strategy in different dimensions, providing standardized feature vectors for subsequent decision-making.

[0038] The system performs multi-objective optimization calculations based on the weight parameters defined in the intent vector representation, analyzing the user's true preferences and associating weight adjustments with keywords in the natural language input. For example, if words such as "fast," "performance," or "experience" are detected, the performance weight w_perf is increased by 0.1; if words such as "saving money," "cost," or "budget" are detected, the cost weight w_cost is increased by 0.1. All weights are initialized to 1 / N (where N is the number of targets) and are normalized after adjustment. Abstract requirements such as "prioritizing experience" are translated into specific numerical weight assignments, such as "performance weight 0.6, cost weight 0.2, and reliability weight 0.2." Subsequently, the system adopts the non-dominated sorting genetic algorithm as the multi-objective optimization algorithm. First, three objective functions to be optimized are defined, corresponding to minimizing the predicted response time, minimizing the predicted resource cost, and minimizing the predicted failure rate. Through operations such as inheritance, crossover, and mutation, a population composed of candidate strategies is iteratively evolved, and finally a set of Pareto optimal solutions is obtained. From this set of optimal solutions, the final solution that best meets the user's preferences is selected, and the normalization function is used to process the predicted values ​​of each target into a unified interval. Then, these indicator values ​​are multiplied by the corresponding preference weights parsed from the user intention vector representation, and added together to obtain a comprehensive score that can fully reflect the user's preferences.

[0039] The system uses an intelligent strategy selection algorithm to select the preferred strategy that best meets the user's overall input as the final solution. Specifically, the system weights the performance, cost, and reliability predictions of each strategy in the Pareto optimal solution set to obtain a comprehensive score. The strategy with the highest score is then selected as the preferred strategy. Specifically, if the difference in the highest scores of multiple strategies is less than a preset threshold (e.g., 5%), the risk predictions of these strategies (provided by the prediction model) are further compared, and the strategy with the lowest risk is selected as the final solution to enhance the robustness of the decision. For example, in the case of the education platform, the algorithm comprehensively considers the user's high performance requirements and selects the strategy that excels in both performance and overall balance as the orchestration strategy.

[0040] A multi-objective optimization algorithm is used to quantitatively score and select candidate strategies. This algorithm systematically weighs trade-offs across multiple dimensions, such as performance and cost. It can then identify and arrive at a balanced solution among conflicting objectives that best meets the user's overall preferences and satisfies various constraints.

[0041] Furthermore, the orchestration strategy is received, feature mapping inference is performed through a generative neural network, calculation parameters are obtained, and the orchestration strategy is converted into an instruction set; the corresponding orchestration execution module; the specific implementation process includes: The system receives the orchestration policy and performs deep feature extraction using a generative neural network driven by a large language model. Generative neural networks have been specifically trained in the cloud-native field and can accurately understand the technical concepts and operational logic in the policy description. The network identifies key elements in the policy, such as key operation types, target resource objects, configuration parameter requirements, and execution timing constraints, and converts these abstract descriptions into structured feature representations. For example, when the orchestration policy is "implementing elastic scaling based on request volume for the product service of an e-commerce website, automatically adding Pod replicas during traffic peaks, and ensuring service response time is less than 200 milliseconds," the key features extracted by the generative neural network include: the target service is "product service," the operation type is "elastic scaling," the trigger condition is "change in request volume," the performance target is "response time less than 200 milliseconds," and the execution action is "adding Pod replicas."

[0042] The system uses a probabilistic graph model to perform vector calculations on each orchestration strategy step to obtain computing parameters for resources including complete identification and existing labels. The probabilistic graph model analyzes all resource objects involved in strategy execution and their dependencies by constructing a probabilistic network of resource dependencies. When processing the "add Pod replicas" step, the probabilistic graph model identifies the directly related Deployment objects and further analyzes the related Service configurations, Ingress rules, underlying Node resources, etc. The model calculates the impact probability and dependency strength between resources through probabilistic reasoning, obtains the complete identification information, metadata labels, and current configuration status of each related resource, and forms a set of computing parameters containing precise context. For example, the system obtains the current Deployment configuration of a commodity service, including complete information such as the number of existing replicas, resource request limits, image versions, and key parameters such as the Service's port configuration and selector labels.

[0043] The large language model uses deep learning to master the grammatical rules and best practices of various cloud-native configuration languages. Combined with a template matching algorithm, it generates standard configuration code based on policy requirements. The template matching algorithm includes standard configuration templates for commonly used cloud-native resources to ensure that the generated configuration meets best practice requirements. During the code generation process, the system automatically applies cloud-native security best practices, automatically adding security context configuration when generating Pod templates, and setting security measures such as non-root user execution and read-only root file systems. Finally, the system generates an instruction set containing cloud-native configurations through a variational autoencoder. The variational autoencoder uses an encoder-decoder architecture to encode abstract policy requirements into a latent space representation. The decoder converts these representations into configuration files in a specific format. As a "configuration space explorer," the variational autoencoder learns a low-dimensional, continuous configuration design space by training on a large number of excellent YAML configuration samples. This provides two core capabilities: first, by performing vector interpolation within this space, it generates novel hybrid configurations that conform to specific design patterns. Second, by "encoding and then decoding" a non-standard configuration, it can assist in correcting grammatical or structural deviations at the format and structure level, bringing it more in line with best practices in the training data. This improves the quality and compliance of the resulting instructions and enhances the system's automated compliance capabilities. The system generates a complete set of instructions, including Deployment configurations, HorizontalPodAutoscaler automatic scaling rules, and Service load balancing configurations.

[0044] This achieves automated and reliable conversion from orchestration strategies to specific sets of instructions. By leveraging the code generation capabilities of large language models and combining them with templates, it reduces the potential for human errors introduced when manually writing configuration files and improves the format correctness and executable nature of the generated instructions.

[0045] Furthermore, the state transition is completed through the reinforcement learning agent, and the execution result data is output; the corresponding orchestration execution module; the specific implementation process includes: The system receives a set of configuration instructions and establishes an adaptive connection with the cloud-native control plane through a reinforcement learning agent. The reinforcement learning agent uses a Q-learning algorithm to optimize the connection strategy. By interacting with the cloud-native environment, it learns connection parameters and retry mechanisms, enabling adaptive adjustments to dynamic environmental changes such as network latency and connection timeouts. Through reinforcement learning, the agent continuously improves connection stability and efficiency, verifies environmental status and operational permissions, and ensures the readiness of the execution environment. For example, when deploying an autoscaling policy, the reinforcement learning agent learns connection timing and parameter configurations to establish an efficient and stable control plane connection. The reinforcement learning agent also features a new drill mode. In this mode, the agent proactively responds to various simulated failures in an isolated sandbox environment to learn optimal emergency recovery strategies. The goal is no longer simply deployment; it also includes restoring service health in the shortest possible time. Available actions now include emergency operations such as restarting services, switching traffic, and rolling back changes. Successful recovery paths learned during drills can automatically generate and validate standardized "automated recovery plans," expanding the system's capabilities from reactive response to proactive defense, improving recovery efficiency in failure scenarios and enhancing the system's overall resilience and defense capabilities.

[0046] The system applies an intelligent scheduling algorithm to execute each instruction sequentially according to the execution sequence defined in the instruction set. Based on dependency analysis and resource status assessment, the intelligent scheduling algorithm dynamically optimizes the execution order of instructions, ensuring the correct dependencies for resource creation. It also employs priority queuing and dynamic scheduling mechanisms to adjust execution strategies in real time based on resource availability and system load. The execution process follows a "pre-check-apply-verify" model, with each instruction optimized by the intelligent scheduling algorithm. When applying autoscaling configurations, the intelligent scheduling algorithm prioritizes Deployment resource updates before creating the HorizontalPodAutoscaler and monitoring configuration in the optimal order. This intelligent scheduling algorithm, acting as a dynamic task orchestrator, transforms the instruction set into a "to-be-executed task graph" that incorporates dependencies and risk attributes. During execution, it dynamically calculates an "execution readiness score" for each ready task, which combines priority, risk level, and current system load, and prioritizes the highest-scoring task. This mechanism ensures that the optimal execution path is dynamically selected throughout the change process, balancing efficiency and security. This improves the security of change execution and enhances the dynamic scheduling capabilities of complex tasks.

[0047] The system uses a deep learning network to record the execution results and status information of each command application. This deep learning network utilizes a multi-layer neural network architecture to capture and analyze key data during command execution in real time, including resource creation status, configuration validation status, and error events. Using a feature learning mechanism, the network automatically identifies important patterns and anomalies during execution, generating detailed execution logs. Simultaneously, the system utilizes a time series analysis neural network to record the actual impact of configuration changes on infrastructure status. Using an LSTM architecture, this neural network learns the temporal changes in system status, capturing the dynamic evolution of key metrics such as changes in the number of pod replicas, resource utilization trends, and improvements in service response time, generating a quantitative impact analysis report. Finally, the system uses an attention mechanism to generate execution result data containing execution status, information, and resource change details. This attention mechanism dynamically focuses on key information during execution, intelligently integrating multiple data sources, including the execution logs recorded by the deep learning network and the impact analysis generated by the time series analysis network, to generate structured execution result data.

[0048] It defines a controlled and observable instruction execution and data collection process. It uses reinforcement learning agents to precisely apply instructions and employs methods such as timing analysis to record the actual impact on infrastructure, providing high-fidelity, reliable feedback data for subsequent performance evaluation and model learning.

[0049] Furthermore, the execution result data and input data are received, and the user input is converted into verification logic through the large language model to perform neural network training. When the network parameters change, weight update events are generated; this corresponds to the model training module. The specific implementation process includes: After receiving the execution result data from the orchestration execution module and the user's original input data, the system initiates the performance verification process. This process first uses a large language model to parse the user's natural language intent, such as "Ensure the e-commerce website response time does not exceed 200 milliseconds." To convert this intent into a machine-readable evaluation benchmark, the model matches the most relevant "latency" template from a structured validation rule library. This template predefines fields such as kpi_name (metric name), metric_source (data source query statement), and comparison_operator (comparison operator). The large language model extracts the value "200" from the user's intent and populates it in the template's target_value field, generating an instantiated, directly executable validation rule.

[0050] Based on this instantiated rule, the system immediately executes the query defined in its metric_source field and obtains the current actual value of the KPI from the cloud-native environment's monitoring system. For example, the actual P95 response time is 180 milliseconds. The system then compares this actual value (180) with the target value (200) determined by the user intent in the rule, calculates the specific deviation (-20 milliseconds) or achievement rate (110%), and generates a structured deviation data object. When the user intent contains multiple targets, the system processes all validation rules in parallel and aggregates their respective deviation data objects into a comprehensive evaluation report.

[0051] This assessment report is then fed into the logical judgment module, which evaluates the report data based on pre-set trigger conditions (e.g., "When the achievement rate of the 'Response Time' metric exceeds 105% for three consecutive assessment cycles, and the deviation of the 'Cost Growth' metric is negative"). Once the data in the report meets a pre-set logical condition, the system generates a structured weight update event. This event clearly records the specific rule ID that triggered the event, detailed deviation data that caused the trigger, the identifier of the currently executing policy, and clear adjustment recommendations for subsequent self-learning modules, such as "Increase the recommendation weight of the current policy."

[0052] A quantitative feedback verification mechanism is established to accurately evaluate the effectiveness of the strategy by comparing actual execution results with the user's original goals. When significant performance deviations are detected, structured update events are generated, providing a clear signal to initiate the learning process.

[0053] Furthermore, it receives weight update events, processes the data through neural networks, generates improved orchestration strategies, and sends them back to the orchestration execution module to form an adaptive learning mechanism; for the autonomous learning module, see Figure 2 ; The specific implementation process includes: The system first receives the weight update event emitted by the model training module and uses this event as a time reference point to extract and correlate various contextual data related to it. Based on the event's timestamp, the system retrieves a snapshot of the system status for a specific period, the period before and after the event, from historical monitoring data and configuration change records. This snapshot is a comprehensive data set that integrates information from multiple dimensions. It includes not only the change sequence of the key performance indicator (KPI) that triggered the event, but also the orchestration policy in effect at the time, related resource configuration parameters such as CPU and memory limits and the number of replicas, and other potentially relevant environmental indicators. This process transforms the originally isolated "weight update event" into a "learning sample" rich in contextual information, suitable for in-depth analysis.

[0054] The system uses a large language model to perform correlation analysis on this "learning sample" to identify factors highly correlated with performance changes. This process first uses the Pearson correlation coefficient to calculate feature importance, thereby selecting candidate factors that are statistically most relevant to performance changes. These preliminarily selected candidate factors, along with relevant contextual information, are then presented to the large language model via a structured prompt. This structured prompt engineering guides the large language model in generating appropriate hypotheses. The prompt includes three components: the system state before policy execution, the specific policy steps executed, and the performance changes recorded after policy execution. The large language model analyzes this information and outputs a list of policy steps or configuration parameters it deems most relevant to the final performance results. For example, it identifies a high temporal correlation between increasing the number of pod replicas from 3 to 5 and a 20% decrease in response time.

[0055] Based on the conclusions drawn from the correlation analysis generated in the previous step, the system will give new prompts to the large language model. This prompt includes the existing and proven orchestration strategies, as well as the list of "highly relevant factors" identified in the previous stage, instructing the model to carry out corresponding enhancements or make subtle adjustments around these key factors while ensuring that the core logic of the successful strategy is retained, and then generate new candidate strategy solutions. For example, if "increasing Pod replicas" is identified as the key, the model will make suggestions to set the trigger threshold of the elastic scaling strategy to be more sensitive, or to introduce an early expansion mechanism based on CPU usage prediction, so as to eventually generate an improved orchestration strategy. The generated improved orchestration strategy is then sent back to the orchestration execution module for re-learning and implementation, thus forming a system-wide adaptive learning mechanism. This process enables the system to self-optimize, forming a complete learning loop. It not only identifies the success or failure of strategy execution, but also analyzes the root causes and autonomously generates improved strategies, allowing the system to continuously improve the accuracy and effectiveness of its decisions as it continues to operate.

[0056] The closed-loop automation system provided by the present invention is composed of five core modules: intent analysis, strategy planning, orchestration execution, model training, and autonomous learning. It clearly and meticulously depicts the complete life cycle process from receiving the user's high-level intent, through specific execution operations, to finally achieving self-optimization based on the feedback of the results. Compared with the traditional decentralized operation and maintenance solutions that are composed of multiple tools, this framework, with its extremely tight coupling relationship between modules and standardized data flow, effectively guarantees that information can be efficiently transmitted throughout the entire end-to-end process. On the one hand, it provides a structured technical blueprint for achieving the goal of high-level intent-driven orchestration. On the other hand, it also lays a solid foundation for the system to achieve continuous and autonomous intelligent evolution with the help of built-in feedback and learning loops.

[0057] Example 2 Operations Engineer B needs to perform cloud-native deployment for a newly launched system. The specific implementation of the intent parsing module is as follows: User B enters the deployment intent: "Deploy a real-time fraud detection system in a production environment. Requirements: high availability, handling 50,000 requests per second, response latency below 100 milliseconds, and compliance with financial data security and compliance standards." After text cleansing, the system loads a large language model fine-tuned specifically for the financial operations domain. The input data is fed into a Transformer neural network architecture, where deep feature encoding is performed using a multi-head self-attention mechanism. The first attention head identifies the core concept of "real-time fraud detection system," the second focuses on the performance requirements of "high availability" and "high concurrency," and the third analyzes the constraints of "financial data security and compliance." Using the word embedding neural network space of the pre-trained model, the encoded results are mapped to a high-dimensional vector space, extracting a parameter set encompassing the core tasks, performance objectives, cost constraints, and priorities. The system uses an expert system rule engine to obtain resource features and operation type vectors for compute nodes, encrypted storage, and other resources marked with a "high security level." The expert system rule engine's built-in rule base contains the following logical rules: The first is a high-availability intent mapping rule. When the system recognizes that the user's intent includes the requirement for "high availability," it automatically adds the technical requirements of "number of replicas should be greater than or equal to 3" and "enabling pod anti-affinity" to the policy requirements. The second is a financial compliance resource classification rule. When the system detects that a compute node's label includes the "financial security level," it automatically adds the "compliance" attribute to the node's resource feature vector. A probabilistic inference algorithm is used to calculate dependency parameters between components, analyzing the dependencies between the fraud detection service and the security components and encryption services. Finally, a fully connected neural network is used to uniformly encode and organize the deep feature encoding, parameter sets, cloud-native resource feature vectors, and dependency parameters, generating a structured vector that integrates the user's security and compliance intent with the constraints of the financial environment.The specific format is as follows: {intentId: fraud-detection-deploy-001, userInput: Production environment deployment for real-time fraud detection system..., parsedIntent: {coreTask: deploy, applicationName: fraud-detection-system, environment: production}, constraints: {availability: high, performance: {requestsPerSecond: 50000, latencyMilliseconds: 100}, security: {complianceStandard: financial-data}}, systemSnapshot: {nodes: [...], storageClasses: [...], dependencies: {...}}, preferenceWeights: {security: 0.5, performance: 0.3, cost: 0.2}}.

[0058] In this format, the system assigns a unique intent ID (intentId) to each request for full tracking and fully preserves the user's original input (userInput). It then parses the input, extracting the core task (such as coreTask), target application name (applicationName), and operating environment (environment) and storing them in a parsed intent (parsedIntent) object. More importantly, it records all constraints in detail, including availability requirements, specific performance metrics (such as requests Per Second and latency Milliseconds), and security compliance standards that must be followed. To ensure that the subsequently generated policies are feasible, the format also includes a system snapshot (systemSnapshot) to reflect the actual status of computing nodes, available storage types (storageClasses), and dependencies between components in the cloud environment at the moment the instructions are received. Finally, the system will intelligently analyze the user's language and convert their emphasis on different goals into quantified preference weights (preferenceWeights), so that the trade-offs and decisions that best suit the user can be made during subsequent multi-objective optimization.

[0059] The system receives structured vectors and uses a knowledge graph inference network to extract key features and entity embedding vectors, constructing a semantic entity relationship graph. Key entity nodes are identified as "fraud detection system," "high concurrency processing," "data encryption," and "security and compliance." The system uses fuzzy logic inference algorithms to perform vector calculations within the dynamic knowledge structure, dynamically adjusting the importance weights of nodes and edges in the graph based on the security and compliance requirements of the financial environment. In a financial security environment, the correlation strength between the "data encryption" and "compliance standards" nodes is significantly enhanced. The system uses a decision tree learning algorithm to learn vector representations of cloud-native resource nodes, processing the topological relationships and attribute features of high-security compute nodes, encrypted storage resources, and network security components. The system obtains the current configuration parameters, operational status vectors, and dependency matrices of the resources. Configuration parameters include static information such as security level, encryption configuration, and compliance labels, while the operational status vectors include dynamic information such as security monitoring indicators and encryption status. Finally, a multimodal fusion neural network aligns features between user input and system data, processing user security and compliance semantics and system security status data to generate a context-rich intent vector representation.

[0060] Example 3 In cloud-native deployments, the specific implementation of the policy planning module is as follows: The system receives an intent vector representation and, leveraging the generative reasoning and combinatorial generalization capabilities of a large language model, generates multiple candidate decision strategy vectors. Based on its deep understanding of financial cloud-native domain knowledge and the specific security and compliance scenarios of a real-time fraud detection system, the large language model designs multiple implementation paths to meet User B's high concurrency, low latency, and security compliance requirements. The generated candidate strategies include: a vertical scaling strategy that increases the CPU and memory configuration of a single instance to enhance processing power while also strengthening security and encryption capabilities; a horizontal scaling strategy that distributes the load by increasing the number of service instances and implements multi-layer security redundancy; and a hybrid optimization strategy that combines intelligent caching, database security separation, and encrypted transmission acceleration to achieve comprehensive improvements in security and performance. The system then invokes a random forest-based prediction model for each decision strategy. This ensemble learning model constructs multiple decision trees in parallel for prediction. The performance prediction submodel analyzes metrics such as response time, concurrent processing capacity, and security detection latency; the cost prediction submodel assesses the cost of computing resources, security components, and compliance monitoring; and the reliability prediction submodel focuses on metrics such as system stability, security protection capabilities, and fault recovery time. The system also uses genetic algorithms to optimize and analyze strategies, simulating their performance during peak financial trading periods and security attack scenarios. It assesses each strategy's robustness and security protection capabilities under unusual conditions such as traffic surges, security threats, and node failures. The system applies machine learning algorithms to predict the execution outcomes of each strategy based on performance metrics, cost overhead, and reliability, taking into account the unique requirements of the financial environment. Ultimately, an ensemble learning approach is used to generate a strategy evaluation vector containing the predicted data, integrating various prediction indicators, security compliance assessments, and risk analysis results.

[0061] After receiving the policy evaluation vector, the system uses a convolutional neural network to extract predictions from each decision strategy across different dimensions. The convolutional neural network utilizes a multi-channel architecture to process predictions across dimensions such as performance, cost, and security compliance, identifying the strengths and weaknesses of each strategy: the vertical scaling strategy excels in secure encryption but comes at a higher cost; the horizontal scaling strategy offers more balanced concurrency processing but requires more complex security configuration; and the hybrid optimization strategy offers advantages in comprehensive security protection. The system then performs a multi-objective optimization calculation based on the weighting parameters defined in the intent vector representation. This calculation interprets User B's high-priority requirement for "financial data security compliance" and translates it into a specific weighting distribution: "security compliance weighting 0.4, performance weighting 0.4, and cost weighting 0.2." A scoring vector is generated by the multi-objective decision-making algorithm. The algorithm comprehensively considers the security compliance and performance requirements of the financial environment and calculates a comprehensive score for each candidate strategy. Subsequently, an intelligent strategy selection algorithm selects the preferred strategy that best meets the user's overall input as the final solution. Based on the scoring vector and the specific weightings for financial security compliance, the algorithm identifies the hybrid optimization strategy as the orchestration strategy that best meets User B's overall security compliance intent.

[0062] Example 4 In cloud-native deployment, the specific implementation of the orchestration execution module is as follows: After receiving the complete orchestration policy, the system performs deep feature extraction using a generative neural network driven by a large language model. This generative neural network, trained in the financial cloud-native domain, identifies key elements within the policy, such as key operation types, target resource objects, and security configuration requirements. It then transforms the abstract hybrid optimization policy description into a structured feature representation. The system then applies a probabilistic graphical model to perform vector calculations for each orchestration policy step, obtaining computational parameters for resources with complete identification and existing labels. This probabilistic graphical model constructs a probabilistic network of resource dependencies within the financial security environment, analyzing security resource objects such as StatefulSets and NetworkPolicies involved in policy execution and their dependencies. Using probabilistic reasoning, the model calculates the impact probability and dependency strength between security resources, obtaining the complete identification information, security labels, and current configuration status of each relevant resource. The system then leverages the code generation capabilities and template matching algorithms of the large language model to convert the abstract policy into executable instructions. The large language model, combined with the template matching algorithm, generates standard configuration code based on financial security compliance requirements, automatically applying financial cloud-native security best practices. Finally, a variational autoencoder generates an instruction set in a format that includes cloud-native configurations. The variational autoencoder encodes abstract security policy requirements into latent space representations, and the decoder converts these representations into a complete set of instructions such as specific Kubernetes security configuration and encryption service configuration.

[0063] After receiving a set of configuration instructions, the system establishes an adaptive connection to the cloud-native control plane through a reinforcement learning agent. It leverages a built-in retry mechanism with exponential backoff and dynamically adjusts connection timeouts and request rates based on metrics such as network latency and API server load collected from monitoring systems. The system then applies each instruction sequentially using an intelligent scheduling algorithm, following the execution sequence defined in the instruction set. It first resolves dependencies between instructions (for example, a ConfigMap must be created before it can be mounted on a Pod) and generates a directed acyclic graph (DAG) as the execution plan. During execution, the scheduler strictly adheres to the topological order of this graph and applies each instruction based on real-time resource availability checks on the target nodes. During execution, the system uses a deep learning network to record the execution results and status of each instruction. This deep learning network captures key data during instruction execution in real time, including the creation status of security resources and the effectiveness of encryption configurations, generating detailed security execution logs. Furthermore, a time series analysis neural network is used to record the actual impact of configuration changes on infrastructure status. The time series analysis neural network uses an LSTM architecture to learn the temporal changes in the system's security status, capturing the dynamic evolution of key indicators such as protection effectiveness and performance impact after security policy deployment. Ultimately, an attention mechanism is used to generate execution result data containing execution status, information, and resource change details. This attention mechanism dynamically focuses on key information during the financial security deployment process, intelligently integrating data such as security execution logs recorded by the deep learning network and security impact analysis generated by the time series analysis network to generate structured execution result data.

[0064] Example 5 In cloud-native deployment, the specific implementation of model training and autonomous learning modules is as follows: The system initially receives execution result data from the orchestration execution module, along with the data originally entered by user B, and then begins the performance verification process. The key to this process lies in leveraging a large language model and a structured validation rule base to parse and translate user intent expressed in natural language—such as "QPS must be greater than 50k" or "Latency must be less than 100ms"—into machine-readable evaluation criteria. The system has a built-in, ongoing monitoring and analysis pipeline that collects relevant time-series performance data from the cloud-native environment. It also uses time series models such as recurrent neural networks (RNNs) to smooth and analyze trends, generating stable and reliable actual performance metrics. For example, the current average QPS is 52k, the average response latency is 95ms, and the security check pass rate is 99.8%. The system then continuously compares these actual performance metrics against the evaluation criteria, using anomaly detection models to identify any statistically significant deviations. If a positive deviation is detected that meets the preset trigger conditions, that is, when the performance goals are consistently achieved and security compliance is good, the system will automatically generate a structured weight update event, which contains detailed performance data and contextual information, and proposes to increase the recommended weight of the current hybrid optimization strategy.

[0065] After receiving a weight update event, the system initiates an autonomous learning and policy improvement process. First, using the event as a time anchor, it extracts snapshots of system state and executed policy configurations from historical records for the period surrounding the event, constructing a context-rich "learning sample." In this step, a graph neural network (GNN) is used to effectively represent the complex dependencies between resources, configurations, and metrics in this sample, forming structured graph data. The system then applies a large language model to perform correlation analysis on this structured learning sample. Through carefully designed prompting, the model is guided to identify and output a list of key influencing factors highly correlated with the positive performance results. Finally, the system again utilizes the large language model, feeding the original successful strategy and this list of key influencing factors as input. This prompts the model to enhance or fine-tune these key factors while preserving the core logic, thereby autonomously generating new, recommended improved orchestration strategies. For example, the model might recommend optimizing the GPU resource allocation algorithm or enhancing the cache warming mechanism. These newly generated strategies are then fed back into the candidate pool of the policy planning module, completing the adaptive learning loop and continuously optimizing the system's decision-making capabilities in high-concurrency financial environments.

[0066] While embodiments of the present invention have been shown and described, it will be appreciated by those skilled in the art that various changes, modifications, substitutions, and variations may be made to these embodiments without departing from the principles and spirit of the invention, and that the scope of the invention is defined by the appended claims and their equivalents.

Claims

1. A cloud-native application intent-driven intelligent orchestration system based on a large language model, characterized by: include: The intent parsing module receives input data, extracts features, and performs vectorized decomposition using a large language model. It encodes intent features using a knowledge graph, reduces training bias, and outputs an intent vector representation. The strategy planning module receives the intent vector representation, generates a decision strategy through a multi-objective optimization algorithm, calls the prediction model for model inference, and obtains a strategy evaluation vector. It then optimizes the strategy based on the weight parameters and outputs the orchestration strategy. The orchestration execution module receives the orchestration strategy, performs resource analysis through the feature mapping network, obtains computing parameters, and converts the orchestration strategy into an instruction set; Complete state transitions through reinforcement learning agents and output execution result data; The model training module receives execution result data and input data, converts user input into verification logic through a large language model, performs neural network training, and generates weight update events when network parameters change; The autonomous learning module receives weight update events, performs neural network processing on the data, generates improved orchestration strategies, and sends them back to the orchestration execution module to form an adaptive learning mechanism.

2. A cloud-native application intent-driven intelligent orchestration system based on a large language model according to claim 1, characterized in that: The specific implementation process of feature extraction and vectorization decomposition includes: sending input data into a large language model fine-tuned in the operation and maintenance field; performing deep feature encoding through the multi-head self-attention mechanism of the Transformer neural network architecture; using the word embedding neural network space of the pre-trained model to obtain a parameter set containing core tasks, performance goals, cost constraints and priorities; extracting cloud native resource features and operation type vectors through the expert system rule engine; using a probabilistic reasoning algorithm to calculate the dependency parameters between components; and organizing the extracted deep feature codes, parameter sets, cloud native resource feature vectors and dependency parameters into structured vectors through fully connected neural network encoding.

3. The cloud-native application intent-driven intelligent orchestration system based on a large language model according to claim 1 is characterized in that: The specific implementation process of the output intent vector representation includes: receiving a structured vector; extracting key features and entity embedding vectors through a knowledge graph reasoning network; performing vector calculations in a dynamic knowledge structure using a fuzzy logic reasoning algorithm; learning vector representations of cloud-native resource nodes through a decision tree learning algorithm; obtaining the current configuration parameters, operating status vectors, and dependency matrices of resources; aligning features of user input with system data through a multimodal fusion neural network; and generating an intent vector representation.

4. The cloud-native application intent-driven intelligent orchestration system based on a large language model according to claim 1 is characterized in that: The specific implementation process of the model reasoning includes: receiving the intention vector representation, generating multiple candidate decision strategy vectors through the generative reasoning ability and combinatorial generalization ability of the large language model; calling a random forest-based prediction model for each candidate decision strategy vector; performing strategy optimization analysis through a genetic algorithm; obtaining prediction data on performance indicators, cost overhead and reliability; and generating a strategy evaluation vector containing the prediction data through an ensemble learning method.

5. The cloud-native application intent-driven intelligent orchestration system based on a large language model according to claim 1 is characterized in that: The implementation process of the output orchestration strategy includes: receiving the strategy evaluation vector, extracting the prediction results of each decision strategy in different dimensions through a convolutional neural network; performing multi-objective optimization calculations based on the weight parameters defined in the intent vector representation to obtain a scoring vector; and using an intelligent strategy selection algorithm to select a strategy that meets the user's overall input as the orchestration strategy.

6. The cloud-native application intent-driven intelligent orchestration system based on a large language model according to claim 1 is characterized in that: The generation process of converting the orchestration strategy into an instruction set includes: receiving the orchestration strategy and performing deep feature extraction through a generative neural network; applying a probabilistic graphical model to perform vector calculations on each orchestration strategy step to obtain calculation parameters for resources including complete identifiers and existing labels; utilizing the code generation capabilities and template matching algorithms of a large language model to convert the abstract strategy into executable instructions; and generating an instruction set including cloud-native configurations through a variational autoencoder.

7. The cloud-native application intent-driven intelligent orchestration system based on a large language model according to claim 1 is characterized in that: The specific implementation process of outputting the execution result data includes: receiving an instruction set, establishing a connection with the cloud native control plane through a reinforcement learning agent; applying each execution instruction in sequence according to the execution sequence defined in the instruction set using an intelligent scheduling algorithm; recording the execution results and status information of each instruction application through a deep learning network; using a timing analysis neural network to record the actual impact of configuration changes on the infrastructure status; and generating execution result data containing execution status, information, and resource change details through an attention mechanism.

8. The cloud-native application intent-driven intelligent orchestration system based on a large language model according to claim 1 is characterized in that: The specific implementation process of generating the weight update event includes: simultaneously receiving the execution result data and the input data, and using a large language model to assist in converting the performance goals and constraints in the user input into verification logic based on preset rules; establishing a continuous learning mechanism and using a reinforcement learning algorithm to continuously run training and reasoning; obtaining a key indicator vector reflecting the current system status through a monitoring data processing neural network; using a statistical learning algorithm to perform numerical calculations on the actual status indicator and the target vector; and generating a weight update event based on preset trigger conditions.

9. The cloud-native application intent-driven intelligent orchestration system based on a large language model according to claim 1 is characterized in that: The specific implementation process of forming the adaptive learning mechanism includes: receiving the weight update event, extracting detailed parameter information and context data through the graph neural network; using the large language model to perform inference calculation and correlation analysis on the data, and mining highly correlated influencing factors; calculating the influencing factors and correlation paths that lead to changes in system parameters through the neural network algorithm; using the generative neural network to autonomously learn and generate an improved orchestration strategy based on the inference calculation conclusions; sending the generated improved orchestration strategy back to the orchestration execution module for re-learning and implementation, thereby forming an adaptive learning mechanism.

Images