Intelligent computer resource allocation method and system based on artificial intelligence

Abstract

The invention discloses an intelligent computer resource allocation method and system based on artificial intelligence, and belongs to the technical field of artificial intelligence, and the method comprises the steps: collecting multi-layer resource monitoring data, and constructing a cross-level resource dependence graph. Root cause sensitivity and historical time sequence data are combined, a resource demand fluctuation trend is accurately predicted through LSTM, a time elastic coefficient of a task to a resource is quantified, and a resource time elastic matrix is generated, so that resource allocation has a dynamic time sequence adaptive capability, resource idleness and sudden congestion are effectively avoided, a resource reuse rate and task scheduling flexibility are improved, and resource allocation efficiency is improved. The elastic scheduling space is released while the key service SLA is guaranteed, and the load fluctuation coping toughness and the resource utilization efficiency of the system are remarkably enhanced.

Description

Technical Field

[0001] This invention belongs to the field of artificial intelligence technology, specifically referring to a method and system for intelligent allocation of computer resources based on artificial intelligence. Background Technology

[0002] With the widespread application of artificial intelligence, cloud computing, microservice architecture and large-scale distributed systems, modern computing environments are characterized by high heterogeneity, dynamic coupling and cross-layer dependencies. Hardware resources, operating system resources and application layer services form a complex interactive network. Resource bottlenecks or anomalies at any level may be transmitted to other levels through implicit paths, causing system-level performance degradation or even service interruption. Traditional static resource allocation strategies are no longer able to meet the operation and maintenance requirements of high availability, high efficiency and high elasticity.

[0003] However, current intelligent allocation methods for computer resources still have certain shortcomings. Existing technologies suffer from systemic defects such as coarse data fusion, lack of causal reasoning, insufficient time elasticity modeling, one-sided understanding of resource coupling effects, lack of coordination and interpretability in allocation mechanisms, weak security of refactoring execution, and inability of models to self-evolve. These defects make it difficult to accurately perceive cross-layer dependencies, precisely locate root causes, flexibly schedule time-series resources, and avoid hidden performance conflicts in complex dynamic environments. Ultimately, this results in a disconnect between allocation strategies and actual operation, limiting resource utilization, system stability, and long-term adaptability. Therefore, this paper proposes an intelligent allocation method and system for computer resources based on artificial intelligence. Summary of the Invention

[0004] The purpose of this invention is to provide a computer resource intelligent allocation method and system based on artificial intelligence to solve the problems mentioned in the background art.

[0005] To achieve the above objectives, the present invention provides the following technical solution: an intelligent computer resource allocation method based on artificial intelligence, comprising the following steps:

[0006] S1. By collecting multi-level resource monitoring data, construct a cross-level resource dependency graph;

[0007] S2. Based on the resource dependency graph, locate the root cause of resource conflict through causal discovery and output a causal network describing the root cause.

[0008] S3. Based on dependency graphs and causal networks, resource demand plasticity optimization in the time dimension is performed through time series prediction and elastic modeling, and a resource-time elasticity matrix is ​​output.

[0009] S4. Based on dependency graphs and elasticity models, the coupling effect between heterogeneous resources is quantified through nonlinear dynamics analysis, and the resource coupling function is output.

[0010] S5. Based on the elasticity matrix and coupling function, conduct distributed resource negotiation through multi-agent game and output the allocation strategy under Nash equilibrium.

[0011] S6. Perform adaptive reconstruction of physical resource topology according to the allocation strategy, and output the optimized system resource configuration status;

[0012] S7. Based on the actual execution feedback of the reconstructed system, iteratively optimize the causal allocation model by comparing it with counterfactual reasoning, and output the updated model parameters.

[0013] Preferably, in step S1, structured monitoring data is collected in real time from the hardware layer, operating system layer, and application layer. The collected data is timestamped based on a unified time window to eliminate the time-series deviation between high-frequency data in the hardware layer and low-frequency data in the application layer. Resource indicators of different dimensions are mapped to the [0, 1] standardized space through dynamic normalization processing to eliminate the difference in dimensions. Based on the pre-trained temporal embedding model, the standardized multi-layer resource state vector is mapped to the high-dimensional semantic space. The generated embedding vector retains both temporal dynamics and hierarchical correlation. Based on the embedding vector, the propagation weights between resource nodes are iteratively calculated through a graph neural network to output the inter-layer dependency strength matrix. Based on the propagation strength matrix, a dependency graph G(V, E, W) is constructed.

[0014] Preferably, in step S2, all node pairs are extracted from the resource dependency graph G(V, E, W) constructed in step S1. and weight As the initial set of edges for the causal hypothesis, time-series data of resource conflict events (such as sudden increases in system latency) are selected, and each edge in the dependency graph is analyzed. Perform conditional independence tests, side The conditional mutual information value is implemented as follows:

[0015] ,

[0016] In the formula, Representing an edge Conditional mutual information value, This indicates the node under condition C. The conditional entropy, where H represents the entropy function. Indicates the source resource node. Indicates the target resource node.

[0017] Preferably, in step S2, the processed dependency graph is traversed through all triples. ,in ,when and Not adjacent and in a given Under the conditions, and When not independent, determine the collision structure. Based on the defined collision structure, the remaining undirected edges are propagated in the direction using the Meek rule, and a directed acyclic graph is output.

[0018] The directed acyclic graph is transformed into a probabilistic causal Bayesian network, implemented as follows:

[0019] ,

[0020] In the formula, This represents the causal contribution of node X. This represents the set of all paths from node X to system performance node C. for , Denotes the original causal probability of edge e. The preset threshold is used to generate the final causal network, which is then sorted by causal contribution and the root cause nodes are labeled.

[0021] Preferably, in step S3, root cause nodes and causal contributions are extracted from the causal network, and time-sensitive features are constructed by combining system performance indicators. Resource status is aggregated from multi-layer monitoring data according to time windows to generate a structured time-series dataset. .

[0022] Preferably, in step S3, a pre-trained LSTM model is used to predict the distribution of resource demand in future time windows based on the time series T. Combining the prediction results and time sensitivity characteristics, the time elasticity coefficient of each task t with respect to resource v is calculated. The implementation is as follows:

[0023] ,

[0024] In the formula, Represents the causal contribution function. Indicates the volatility of resource demand. Represents the standard deviation function. Representing the demand change sequence, elasticity coefficients are integrated into a resource-time elasticity matrix. Output the resource-time elasticity matrix A.

[0025] Preferably, in step S4, the dependency graph G(V, E, W), resource-time elasticity matrix A, and continuously collected multi-layer monitoring historical data are obtained. For each time point t, the monitoring data is sorted by resource node. Alignment, generating basic state , For node v, calculate the weighted elastic state. By concatenating the states of all nodes according to the time series, a system-level dynamic state sequence is formed. , for ;

[0026] Preset neural differential: ,in Represents a multilayer perceptron, parameters It is learnable, based on D as training data, and minimizes the predicted state. Compared to the actual state The mean squared error, After convergence, the output is the dynamic evolution function after training is complete. .

[0027] Preferably, in step S4, based on the dynamic evolution function And the state sequence D, for each pair of resource nodes Extracting state subsequences from D ,pass Generate enhanced trajectories and calculate mutual information. Output mutual information matrix , ;

[0028] The average partial derivative of the comparable matrix on the trajectory is calculated based on the mutual information matrix and the dynamic evolution function. ;

[0029] The resource coupling function is:

[0030] ,

[0031] In the formula, Represents the system state vector. Represents a symbolic function.

[0032] Preferably, in step S5, the resource-time elasticity matrix, resource coupling function, current task queue, and real-time resource pool status are obtained; each task to be assigned is instantiated as an independent agent; and the physical resource pool is modeled as a shared environment. Based on the agent and environment model, a hierarchical negotiation mechanism is used: the first round broadcasts resource demand intentions; the second round makes local adjustments based on environment feedback; when multiple agents request resource combinations with antagonistic effects, the environment triggers a conflict warning to guide the agents to actively adjust their requests; and a multi-agent deep deterministic policy gradient framework is used to train a policy network for each agent and design reward signals.

[0033] During training, the coupling function is dynamically invoked to evaluate the resource combination quality of each round's allocation scheme, using the effect intensity as a reward scaling factor. Based on the trained policy network, current task, and resource state, a virtual game is initiated: each agent calculates its optimal response strategy based on historically observed opponent policy distributions. In each iteration: agents submit resource request schemes; the environment invokes the coupling function to verify the global resource combination effect; if a strong antagonistic region is detected, local policy fine-tuning is triggered, and the policy change rate remains below a threshold for a preset number of rounds, while global utility fluctuations remain stable; the equilibrium policy is mapped to a specific allocation instruction; a final feasibility check is performed; and annotated allocation schemes are generated: key synergistic effects and antagonistic points to be avoided are marked, and resource allocation strategies under Nash equilibrium are output based on the generated allocation schemes.

[0034] Preferably, in step S6, the Nash equilibrium allocation strategy is obtained, and the allocation strategy is deconstructed into a set of atomic operation instructions: resource binding instructions, timing scheduling instructions, and cooperative enhancement instructions; based on the physical topology mapping table of the dependency graph, logical resource nodes are mapped to specific physical entities to generate a target topology configuration draft.

[0035] Based on the target topology configuration draft and real-time monitoring data, perform triple verification:

[0036] Capacity verification: Remaining resources on the target node ≥ policy allocation amount;

[0037] Coupling security verification: Call the coupling function to verify that there is no high-risk antagonism in the resource combination in the new topology;

[0038] Service continuity verification: Check whether the migration operation triggers a breach of the critical task SLA;

[0039] If the verification fails: trigger adaptive correction and generate a revised configuration draft;

[0040] Based on the approved configuration draft, the execution phases are divided according to risk level:

[0041] Low risk: Static resource allocation;

[0042] Medium risk: Thermal migration is not a critical task;

[0043] High risk: Network topology reconfiguration, enabling backup links to ensure uninterrupted traffic;

[0044] Embedding for each stage:

[0045] Execution window: The optimal time period is determined based on the elasticity matrix;

[0046] Rollback Anchor Point: Save a system snapshot before each stage and define clear rollback trigger conditions;

[0047] Collaborative reinforcement action: For resource pairs labeled with synergistic effects, perform binding operations synchronously;

[0048] Based on the security execution plan generated above, in case of anomaly: if the rollback condition is triggered, immediately terminate the current stage, roll back to the nearest anchor point, and generate an anomaly report; perform multi-dimensional verification based on the system state and allocation strategy target value after execution; if the verification fails: trigger a fine-tuning loop until convergence; after successful verification, output the optimized system resource configuration status.

[0049] Preferably, in step S7, the optimized system resource configuration status, execution process logs, and reconstructed operational data from continuous monitoring are obtained to construct a three-dimensional alignment table of strategy-execution-result: the allocation strategy instructions, execution plans, actual status, and monitoring results are precisely aligned with the task ID by timestamp; key feedback signals are extracted.

[0050] Positive signal: Actual performance gain of the co-labeled region;

[0051] Negative signals: Unforeseen performance jitter points, fine-tuning triggers, and root causes of rollback events;

[0052] Aligned feedback data, original allocation strategy, coupling function, elasticity matrix, and selection of high-impact decision points;

[0053] Generate counterfactual outcome predictions: extrapolate the system state if different decisions were made at the time based on the parameters of the old model;

[0054] Generate fine-tuning schemes based on components, generate candidate parameter sets, and in an isolated sandbox, completely rerun the S2 to S6 processes with each candidate parameter set. Compare the results with the original model results in multiple dimensions, generate a validation scorecard, prioritize candidate sets that show significant improvement in diagnostic bias correction items, confirm that parameter adjustments do not introduce new risks, and solidify the optimal parameter set: generate model parameter packages with version numbers, and update the causal assignment model parameter packages.

[0055] Preferably, the intelligent allocation system for computer resources based on artificial intelligence includes a resource dependency graph construction module, a causal reasoning and root cause localization module, a temporal elastic modeling module, a resource coupling effect quantification module, a distributed game negotiation module, a topology adaptive reconstruction module, and a causal model iterative optimization module.

[0056] Compared with the prior art, the beneficial effects of the present invention are:

[0057] 1. To address the core issues in existing computer resource allocation technologies, such as rigid static strategies, neglect of cross-layer causal relationships, misjudgment of resource coupling effects, lack of time-dimensional flexibility, and lack of self-evolution capabilities of models, this invention constructs a seven-step closed-loop intelligent allocation system of monitoring-causality-flexibility-coupling-game-reconstruction-iteration. This system achieves dynamic decision-making across the entire chain, from resource dependency perception to physical topology optimization, significantly improving resource utilization and system stability, reducing allocation conflict rates, and enhancing strategy interpretability and continuous model optimization capabilities.

[0058] 2. This invention integrates causal contribution and dynamic characteristics of time dimension, combines root cause sensitivity with historical time series data, accurately predicts the trend of resource demand fluctuation through LSTM, and quantifies the time elasticity coefficient of tasks to resources to generate a resource time elasticity matrix. This enables resource allocation to have dynamic time series adaptability, effectively avoids resource idleness and sudden congestion, improves resource reuse rate and task scheduling flexibility, releases elastic scheduling space while ensuring the SLA of critical business, and significantly enhances the system's resilience to load fluctuations and resource utilization efficiency.

[0059] 3. This invention constructs a system state sequence by integrating dependency graphs, elasticity matrices, and dynamic monitoring data. It uses neural differential equations to learn the nonlinear laws of resource evolution, accurately calculates the mutual information and directional partial derivatives between resource nodes, constructs a signed coupling function, clearly distinguishes between synergistic and antagonistic effects, provides quantitative constraints for resource combination, reveals the heterogeneous resource coupling mechanism from the dynamic essence, effectively avoids performance conflict traps in allocation, guides the generation of highly compatible resource combination schemes, and significantly improves the overall performance stability and resource coordination efficiency of the system.

[0060] 4. This invention transforms resource allocation into a multi-agent distributed negotiation process. Tasks, as autonomous agents, engage in dynamic game theory based on private attributes and environmental feedback. An embedded coupling function verifies the quality of resource combinations in real time. The policy network is trained through deep reinforcement learning and Nash equilibrium is searched iteratively. During negotiation, antagonistic combinations are actively avoided and collaborative paths are strengthened, generating clearly labeled executable policies. This achieves decentralized, adaptive, and efficient negotiation, improving allocation fairness and global utility. The policies are accompanied by collaborative and antagonistic annotations to enhance interpretability, providing intuitive decision-making basis for operation and maintenance, significantly reducing allocation conflict rate and improving system throughput. Attached Figure Description

[0061] Figure 1 The following is the operational flow of the AI-based intelligent computer resource allocation method of this invention. Figure 1 ;

[0062] Figure 2 The following is the operational flow of the AI-based intelligent computer resource allocation method of this invention. Figure 2 ;

[0063] Figure 3 The following is the operational flow of the AI-based intelligent computer resource allocation method of this invention. Figure 3 ;

[0064] Figure 4 The following is the operational flow of the AI-based intelligent computer resource allocation method of this invention. Figure 4 ;

[0065] Figure 5 This is a schematic diagram of the structure of the AI-based intelligent computer resource allocation system of the present invention. Detailed Implementation

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

[0067] Example

[0068] Please see Figures 1-5 As shown, the present invention provides a technical solution comprising the following steps:

[0069] S1. By collecting multi-level resource monitoring data, construct a cross-level resource dependency graph;

[0070] S2. Based on the resource dependency graph, locate the root cause of resource conflict through causal discovery and output a causal network describing the root cause.

[0071] S3. Based on dependency graphs and causal networks, resource demand plasticity optimization in the time dimension is performed through time series prediction and elastic modeling, and a resource-time elasticity matrix is ​​output.

[0072] S4. Based on dependency graphs and elasticity models, the coupling effect between heterogeneous resources is quantified through nonlinear dynamics analysis, and the resource coupling function is output.

[0073] S5. Based on the elasticity matrix and coupling function, conduct distributed resource negotiation through multi-agent game and output the allocation strategy under Nash equilibrium.

[0074] S6. Perform adaptive reconstruction of physical resource topology according to the allocation strategy, and output the optimized system resource configuration status;

[0075] S7. Based on the actual execution feedback of the reconstructed system, iteratively optimize the causal allocation model by comparing it with counterfactual reasoning, and output the updated model parameters.

[0076] In this embodiment, in step S1, structured monitoring data is collected in real time from the hardware layer (CPU utilization, memory bandwidth, IO latency), the operating system layer (process scheduling events, interrupt frequency, thread status), and the application layer (API response time, transaction throughput, error rate). The collected data is timestamped based on a unified time window to eliminate the timing deviation between high-frequency data in the hardware layer and low-frequency data in the application layer. Through dynamic normalization processing, resource indicators of different dimensions are mapped to the [0, 1] standardized space to eliminate the difference in dimensions.

[0077] Specifically, pre-trained temporal embedding models map standardized multi-layer resource state vectors to a high-dimensional semantic space, such as an attention-based encoder. The generated embedding vectors retain both temporal dynamics and hierarchical correlations, such as the temporal correlation between sudden changes in CPU utilization and application latency. Based on the embedding vectors, the propagation weights between resource nodes are iteratively calculated through graph neural networks to learn the dependency propagation path from hardware to OS to application, outputting an inter-layer dependency strength matrix to quantify the propagation probability of "CPU overload → OS scheduling latency → application response timeout".

[0078] Based on the propagation strength matrix, a dependency graph G(V, E, W) is constructed. Node V represents hardware resources (CPU cores), OS resources (process queues), and application resources (service instances). Edge E represents dependencies, such as CPU→memory, indicating that CPU usage affects memory allocation. Weight W represents the strength of causal influence, which is the propagation weight output by the graph neural network.

[0079] In this embodiment, in step S2, all node pairs are extracted from the resource dependency graph G(V, E, W) constructed in step S1. and weight ,in As the initial set of edges for the causal hypothesis, time-series data of resource conflict events (such as sudden increases in system latency) are selected, and each edge in the dependency graph is analyzed. Perform conditional independence tests, side The conditional mutual information value is implemented as follows:

[0080] ,

[0081] In the formula, Representing an edge Conditional mutual information value, This indicates the node under condition C. The conditional entropy, where H represents the entropy function. This represents a source resource node, which can be a resource node in the hardware layer, OS layer, or application layer. Represents the target resource node, and represents the endpoint node of the dependency relationship, such as... , This represents a system performance node.

[0082] By gradually increasing the size of the condition variable set, a judgment is made based on a preset threshold. and Independence under a given condition set C, if If true, remove the edge. .

[0083] In this embodiment, in step S2, all triples are traversed on the processed dependency graph. ,in ,when and Not adjacent and in a given Under the conditions, and When not independent, determine the collision structure. .

[0084] Specifically, based on a defined collision structure, the remaining undirected edges are propagated using the Meek rule to process the triples. , and If they are not adjacent, then the edges Oriented to Repeat this process until it can no longer be directed, and output a directed acyclic graph;

[0085] The directed acyclic graph is transformed into a probabilistic causal Bayesian network, implemented as follows:

[0086] ,

[0087] In the formula, This represents the causal contribution of node X. This represents the set of all paths from node X to system performance node C. for , Denotes the original causal probability of edge e. This represents a preset threshold, generating the final causal network, which includes nodes: key resources in resource conflicts, such as CPU core utilization and memory bandwidth; edges: causal relationships with probabilities, sorted by causal contribution, and labeled with root cause nodes.

[0088] In this embodiment, in step S3, root cause nodes and causal contributions are extracted from the causal network, and time-sensitive features are constructed by combining system performance indicators. This is done from multi-layer monitoring data, including hardware layer COU utilization. OS layer memory bandwidth Application layer API delay Aggregate resource status by time window to generate a structured time series dataset. .

[0089] In this embodiment, in step S3, a pre-trained LSTM model is used to predict the resource demand distribution for future time windows based on the time series T. , for Combining the prediction results and time sensitivity characteristics, the time elasticity coefficient of each task t with respect to resource v is calculated. The implementation is as follows:

[0090] ,

[0091] In the formula, Represents the causal contribution function. Indicates the volatility of resource demand. Represents the standard deviation function. Representing the demand change sequence, elasticity coefficients are integrated into a resource-time elasticity matrix. ,in, Row t represents a task, column v represents a resource node, and the output is a resource-time elasticity matrix A, which represents the elasticity sensitivity of task t to resource v in the time dimension. The larger the value, the greater the space for adjustment of resource allocation time.

[0092] In this embodiment, in step S4, the dependency graph G(V, E, W), the resource-time elasticity matrix A, and the continuously collected multi-layer monitoring historical data are obtained. For each time point t, the monitoring data is sorted by resource node. Alignment, generating basic state , For node v, calculate the weighted elastic state. , for , This represents the set of tasks using resource v, where the states of all nodes are concatenated according to time sequence to form a system-level dynamic state sequence. , for ;

[0093] Preset neural differential: ,in Represents a multilayer perceptron, parameters It is learnable, based on D as training data, and minimizes the predicted state. Compared to the actual state The mean squared error, After convergence, the output is the dynamic evolution function after training is complete. .

[0094] In this embodiment, in step S4, based on the dynamic evolution function And the state sequence D, for each pair of resource nodes Extracting state subsequences from D ,pass Generate enhanced trajectories and calculate mutual information. , for P represents the probability distribution, and the output is the mutual information matrix. , .

[0095] Specifically, the average partial derivative of the comparable matrix on the trajectory is calculated based on the mutual information matrix and the dynamic evolution function. , for ,like hour, , Conversely, it indicates weak coupling. Indicates a preset threshold;

[0096] The resource coupling function is:

[0097] ,

[0098] In the formula, Represents the system state vector. It represents a symbolic function; it takes the system state of resource nodes as input and outputs the signed coupling strength.

[0099] In this embodiment, in step S5, the resource-time elasticity matrix, resource coupling function, current task queue, and real-time resource pool status are obtained. Each task to be assigned is instantiated as an independent agent and assigned private attributes: task type, time elasticity coefficient, and resource preference vector. The physical resource pool is modeled as a shared environment, and the environment status includes: the current availability of each resource node, historical allocation records, and coupling effect heatmap. The core logic of the utility function is defined for each agent: utility = task completion benefit × time elasticity adaptability + resource synergy gain - antagonistic penalty.

[0100] Specifically, based on agent and environment models, a hierarchical negotiation mechanism is used: the first round broadcasts resource demand intentions, and the second round makes local adjustments based on environmental feedback. Agents only disclose resource types and elasticity ranges, hiding private information such as precise deadlines. When multiple agents request resource combinations with antagonistic effects, the environment triggers a conflict warning, guiding agents to proactively adjust their requests. A multi-agent deep deterministic policy gradient framework is used to train a policy network for each agent, with reward signal design as follows:

[0101] Positive rewards: timely task completion, improved resource utilization efficiency, and triggering synergistic effects;

[0102] Negative penalties include resource conflicts, triggering antagonistic effects, and violating time elasticity constraints.

[0103] Specifically, during training, the coupling function is dynamically invoked to evaluate the quality of resource combination schemes in each round of allocation, and the effect intensity is used as a reward scaling factor. Based on the trained policy network, the current task, and the resource state, a virtual game is initiated: each agent calculates its own optimal response strategy based on the historically observed distribution of opponent strategies. In each iteration, the agent submits a resource request scheme; the environment invokes the coupling function to verify the global resource combination effect.

[0104] If a strong antagonistic region is detected, a local strategy fine-tuning is triggered. The strategy change rate remains below the threshold for a preset number of rounds, and the global utility fluctuation is stable. The equilibrium strategy is mapped to specific allocation instructions: resource type, quantity, and precise time window are allocated to each task. A final feasibility check is performed: total resource quantity verification; final review of coupling effects; time conflict detection. Annotated allocation schemes are generated: key synergistic effects and antagonistic points to be avoided are marked, and the resource allocation strategy under Nash equilibrium is output based on the generated allocation scheme.

[0105] In this embodiment, in step S6, the Nash equilibrium allocation strategy is obtained and deconstructed into an atomic operation instruction set: resource binding instruction, timing scheduling instruction, and cooperative enhancement instruction; based on the physical topology mapping table of the dependency graph, logical resource nodes are mapped to specific physical entities to generate a target topology configuration draft.

[0106] Based on the target topology configuration draft and real-time monitoring data, perform triple verification:

[0107] Capacity verification: Remaining resources on the target node ≥ policy allocation amount;

[0108] Coupling security verification: Call the coupling function to verify that there is no high-risk antagonism in the resource combination in the new topology;

[0109] Service continuity verification: Check whether the migration operation triggers a breach of the critical task SLA;

[0110] If the verification fails: trigger adaptive correction, such as replacing the backup node, fine-tuning the time window, and generating a revised configuration draft;

[0111] Based on the approved configuration draft, the execution phases are divided according to risk level:

[0112] Low risk: Static resource allocation, such as reserved memory and storage volume creation;

[0113] Medium risk: Thermal migration is not a critical task; utilize the S3.5 flexible window to select off-peak periods.

[0114] High risk: Network topology reconfiguration, enabling backup links to ensure uninterrupted traffic;

[0115] Embedding for each stage:

[0116] Execution window: The optimal time period is determined based on the elasticity matrix;

[0117] Rollback Anchor Point: Save a system snapshot before each stage and define clear rollback trigger conditions;

[0118] Synergistic reinforcement action: For resource pairs labeled with synergistic effects, perform binding operations synchronously.

[0119] Specifically, based on the security execution plan generated above, in case of anomaly: if the rollback condition is triggered, immediately terminate the current stage, roll back to the nearest anchor point, and generate an anomaly report; perform multi-dimensional verification based on the system state and allocation strategy target value after execution; if the verification fails: trigger a fine-tuning loop until convergence; after successful verification, output the optimized system resource configuration status.

[0120] In this embodiment, step S7 involves acquiring the optimized system resource configuration status, execution process logs, and reconstructed operational data from continuous monitoring; constructing a three-dimensional alignment table of strategy-execution-result: precisely aligning allocation strategy instructions, execution plans, actual status, and monitoring results with task IDs according to timestamps; and extracting key feedback signals.

[0121] Positive signal: Actual performance gain of the co-labeled region;

[0122] Negative signals: Unforeseen performance jitter points, fine-tuning triggers, and root causes of rollback events;

[0123] Aligned feedback data, original allocation strategy, coupling function, elasticity matrix, and high-impact decision points are selected to construct two types of counterfactual scenarios:

[0124] Avoidance-based counterfactual: Suppose that S5 does not avoid a certain antagonistic resource pair, such as forcibly allocating CPU and high-conflict I / O devices, and calls the old coupling function to simulate system behavior.

[0125] Missing counterfactual: Assume that S6 did not execute the cooperative hardening instructions, such as CPU and memory not being allocated on the same node, and simulate performance changes;

[0126] Generating counterfactual outcome predictions: Extrapolating system states under different decisions based on old model parameters, and attribution analysis:

[0127] If the actual performance is significantly better than the avoidance counterfactual method, then verify the effectiveness of the coupling function antagonistic annotation.

[0128] If the actual performance is worse than the missing counterfactual type, the diagnosis of collaborative annotation failure will be made, such as the coupling function misjudging collaboration as antagonism.

[0129] If performance fluctuations exceed expectations within the elastic window, diagnose the elastic coefficient calibration deviation.

[0130] Generate fine-tuning schemes based on components, generate candidate parameter sets, and in an isolated sandbox, completely rerun the S2→S6 process with each candidate parameter set. Compare the results with the original model results in multiple dimensions, generate a validation scorecard, prioritize candidate sets that show significant improvement in diagnostic bias correction items, confirm that parameter adjustments do not introduce new risks, and solidify the optimal parameter set: generate model parameter packages with version numbers, and update the causal assignment model parameter packages.

[0131] In this embodiment, the AI-based intelligent computer resource allocation system includes a resource dependency graph construction module, a causal reasoning and root cause localization module, a temporal elastic modeling module, a resource coupling effect quantification module, a distributed game negotiation module, a topology adaptive reconstruction module, and a causal model iterative optimization module.

[0132] Working principle: By collecting multi-source structured monitoring data in real time from the hardware layer, operating system layer, and application layer, and eliminating the temporal misalignment caused by the difference in cross-layer collection frequency through unified time window alignment, the heterogeneous dimensional indicators are mapped to the standardized numerical space using dynamic normalization technology. Then, the standardized data is converted into high-dimensional semantic vectors using a pre-trained temporal embedding model to deeply capture the temporal evolution law of resource status and cross-layer correlation features. Finally, the dependency propagation path and influence strength between resource nodes are iteratively learned through graph neural network to construct a complete cross-layer dependency graph that represents the interaction relationship between hardware operating system and application layer resources.

[0133] Based on the dependency graph as the initial assumption, and combined with time-series data of resource conflict events, the system performs conditional independence tests to remove spurious causal edges caused by indirect correlations or noise. It then traverses the graph to identify collision structures and propagates the remaining edges in a directional manner according to causal discovery rules, forming a directed acyclic causal structure. This structure is further transformed into a probabilistic causal Bayesian network to quantify the causal contribution path and strength of each resource node to system performance. Finally, based on contribution ranking, the root cause nodes and their causal paths that trigger conflicts are accurately labeled, outputting an interpretable root cause localization network. The system integrates root cause contribution information from the causal network with system performance indicators to construct time-sensitive features and simultaneously aggregates multi-layer monitoring data. Based on the generated structured time-series resource state sequence, a time-series prediction model is used to infer future resource demand fluctuation trends. Combining predicted volatility and root cause sensitivity, the time elasticity coefficients of tasks for various resources are calculated. These coefficients accurately characterize the flexibility of task adjustment in the time dimension, ultimately integrating into a resource time elasticity matrix to clearly identify which tasks possess scheduling elasticity space. The dependency graph elasticity matrix and historical monitoring data are fused to construct a system dynamic state evolution sequence. Neural differential equations are used to model the nonlinear dynamic evolution law of resource states. Mutual information calculations quantify the nonlinear dependency strength between resource nodes, and partial derivative analysis of the dynamic evolution function is used to determine coupling directionality. Finally, a resource coupling function is constructed. The function outputs a signed coupling strength value based on the input resource node pairs and the current system state. Positive values ​​represent synergistic gain effects, while negative values ​​represent antagonistic inhibition effects. Each task to be assigned is modeled as an autonomous agent with private attributes. The physical resource pool is constructed as a shared environment containing a heatmap of real-time states and coupling effects. A hierarchical negotiation mechanism is designed to allow agents to dynamically adjust resource requests while protecting privacy. The environment calls the coupling function in real time to verify the quality of resource combinations and trigger conflict warnings. A multi-agent reinforcement learning framework is used to train the agent's policy. The reward mechanism deeply integrates task completion efficiency, resource synergistic gain, and antagonistic avoidance. A global Nash equilibrium is searched through virtual game iteration, and the equilibrium strategy is then... The process is transformed into specific allocation instructions and a final feasibility check is performed to generate an executable allocation scheme that marks collaborative paths and avoids risk points. The allocation strategy is parsed into atomic operation instructions such as resource binding time-series scheduling and collaborative enhancement. A target configuration draft is generated based on the physical topology mapping relationship. A triple verification mechanism of capacity verification coupled with security verification and service continuity verification is executed. When verification fails, node replacement or window fine-tuning is automatically triggered. After verification passes, the execution phase is divided according to the risk level. Rollback anchor points based on elastic windows and collaborative resource synchronization binding actions are embedded in each phase. The reconstruction operation is executed in stages and the system status is monitored in real time. In case of anomalies, the system is immediately rolled back to a safe point. After the reconstruction is completed, multi-dimensional convergence verification is performed.The system collects reconstructed runtime data, execution logs, and configuration status to construct a precise alignment view of strategy execution results, extracting positive gain and negative bias signals. It selects key decision points to construct avoidance and missing fact scenarios, using historical model parameters to simulate system behavior under hypothetical decisions. Causal attribution is performed by comparing actual and counterfactual results, accurately diagnosing model component biases, generating targeted parameter adjustment plans, and rerunning the entire process in an isolated sandbox for verification. The system prioritizes parameter sets with significant repair effects and no new risks for version solidification, outputting an updated model parameter package with continuous evolution capabilities to drive the allocation model to continuously optimize and iterate based on real system feedback.

[0134] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their likenesses.

[0135] The present invention and its embodiments have been described above. This description is not restrictive, and the accompanying drawings are only one embodiment of the present invention; the actual structure is not limited thereto. In conclusion, if those skilled in the art are inspired by this description and design similar structures and embodiments without departing from the spirit of the invention, such designs should fall within the protection scope of the present invention.

Claims

1. A computer resource intelligent allocation method based on artificial intelligence, characterized in that, Includes the following steps: S1. By collecting multi-level resource monitoring data, construct a cross-level resource dependency graph; S2. Based on the resource dependency graph, locate the root cause of resource conflict through causal discovery and output a causal network describing the root cause. S3. Based on dependency graphs and causal networks, resource demand plasticity optimization in the time dimension is performed through time series prediction and elastic modeling, and a resource-time elasticity matrix is ​​output. S4. Based on dependency graphs and elasticity models, the coupling effect between heterogeneous resources is quantified through nonlinear dynamics analysis, and the resource coupling function is output. S5. Based on the elasticity matrix and coupling function, conduct distributed resource negotiation through multi-agent game and output the allocation strategy under Nash equilibrium. S6. Perform adaptive reconstruction of physical resource topology according to the allocation strategy, and output the optimized system resource configuration status; S7. Based on the actual execution feedback of the reconstructed system, iteratively optimize the causal allocation model by comparing it with counterfactual reasoning, and output the updated model parameters.

2. The intelligent allocation method for computer resources based on artificial intelligence according to claim 1, characterized in that: In step S1, structured monitoring data is collected in real time from the hardware layer, operating system layer, and application layer. The collected data is timestamped based on a unified time window to eliminate the time-series deviation between high-frequency data in the hardware layer and low-frequency data in the application layer. Through dynamic normalization, resource indicators of different dimensions are mapped to the [0, 1] standardized space to eliminate the difference in dimensions. Based on the pre-trained temporal embedding model, the standardized multi-layer resource state vectors are mapped to a high-dimensional semantic space. The generated embedding vectors retain both temporal dynamics and hierarchical correlation. Based on the embedding vectors, the propagation weights between resource nodes are iteratively calculated through a graph neural network to output the inter-layer dependency strength matrix. Based on the propagation strength matrix, a dependency graph G(V, E, W) is constructed.

3. The intelligent allocation method for computer resources based on artificial intelligence according to claim 2, characterized in that: In S2, all node pairs are extracted from the resource dependency graph G(V, E, W) constructed in S1. and weight As the initial set of edges for the causal hypothesis, time-series data of resource conflict events are selected, and each edge in the dependency graph is analyzed. Perform conditional independence tests, side The conditional mutual information value is implemented as follows: ， In the formula, Representing an edge Conditional mutual information value, This indicates the node under condition C. The conditional entropy, where H represents the entropy function. Indicates the source resource node, Indicates the target resource node. This represents a system performance node.

4. The intelligent allocation method for computer resources based on artificial intelligence according to claim 3, characterized in that: In step S2, the processed dependency graph is traversed through all triples. ,when and Not adjacent and in a given Under the conditions, and When not independent, determine the collision structure. Based on the defined collision structure, the remaining undirected edges are propagated in the direction using the Meek rule, and a directed acyclic graph is output. The directed acyclic graph is transformed into a probabilistic causal Bayesian network, implemented as follows: ， In the formula, This represents the causal contribution of node X. This represents the set of all paths from node X to system performance node C. Denotes the original causal probability of edge e. The preset threshold is used to generate the final causal network, which is then sorted by causal contribution and the root cause nodes are labeled.

5. The intelligent allocation method for computer resources based on artificial intelligence according to claim 4, characterized in that: In step S3, root cause nodes and causal contributions are extracted from the causal network, and time-sensitive features are constructed by combining system performance indicators. Resource status is aggregated from multi-layer monitoring data according to time windows to generate a structured time-series dataset. .

6. The intelligent allocation method for computer resources based on artificial intelligence according to claim 5, characterized in that: In step S3, a pre-trained LSTM model is used to predict the distribution of resource demand in future time windows based on the time series T. Combining the prediction results and time sensitivity characteristics, the time elasticity coefficient of each task t with respect to resource v is calculated. The implementation is as follows: ， In the formula, Represents the causal contribution function. Indicates the volatility of resource demand. Represents the standard deviation function. Representing the demand change sequence, elasticity coefficients are integrated into a resource-time elasticity matrix. Output the resource-time elasticity matrix A.

7. The intelligent allocation method for computer resources based on artificial intelligence according to claim 1, characterized in that: In step S4, the dependency graph G(V, E, W), the resource-time elasticity matrix A, and continuously collected multi-layer monitoring historical data are obtained. For each time point t, the monitoring data is sorted by resource node. Alignment, generating basic state For node v, calculate the weighted elastic state. By concatenating the states of all nodes according to the time series, a system-level dynamic state sequence is formed. ; Based on D as training data, minimize the predicted state. Compared to the actual state The mean squared error, After convergence, the output is the dynamic evolution function after training is complete. .

8. The intelligent allocation method for computer resources based on artificial intelligence according to claim 7, characterized in that: In S4, based on the dynamic evolution function And the state sequence D, for each pair of resource nodes Extracting state subsequences from D ,pass Generate enhanced trajectories and calculate mutual information. Output mutual information matrix ; The average partial derivative of the comparable matrix on the trajectory is calculated based on the mutual information matrix and the dynamic evolution function. ; The resource coupling function is: ， In the formula, Represents the system state vector. Represents a symbolic function.

9. The intelligent allocation method for computer resources based on artificial intelligence according to claim 1, characterized in that: In step S5, the resource-time elasticity matrix, resource coupling function, current task queue, and real-time resource pool status are obtained. Each task to be assigned is instantiated as an independent intelligent agent, and the physical resource pool is modeled as a shared environment. Based on the intelligent agent and environment model, a hierarchical negotiation mechanism is used: the first round broadcasts the intention to request resources, and the second round makes local adjustments based on environmental feedback. When multiple intelligent agents request resource combinations with antagonistic effects, the environment triggers a conflict warning to guide the intelligent agents to actively adjust their requests. The policy network is trained for each agent using a multi-agent deep deterministic policy gradient framework, and reward signals are designed accordingly. During training, the coupling function is dynamically invoked to evaluate the resource combination quality of each round of allocation schemes, and the effect strength is used as the reward scaling factor. Based on the trained policy network, the current task and resource status, a virtual game is initiated: each agent calculates its own optimal response strategy based on the historically observed distribution of the opponent's strategy. In each round of iteration, the agent submits a resource request plan. The environment calls the coupled function to verify the global resource combination effect; if a strong antagonistic region is detected, a local policy fine-tuning is triggered, and the policy change rate is lower than the threshold for a preset number of rounds, and the global utility fluctuation is stable; the equilibrium policy is mapped to a specific allocation instruction; annotated allocation schemes are generated: key synergistic effects and antagonistic points to be avoided are marked, and the resource allocation strategy under Nash equilibrium is output according to the generated allocation scheme.

10. The AI-based intelligent computer resource allocation system implemented by the method of claim 1 includes a resource dependency graph construction module, a causal reasoning and root cause localization module, a temporal elastic modeling module, a resource coupling effect quantification module, a distributed game negotiation module, a topology adaptive reconstruction module, and a causal model iterative optimization module.

Images