Cloud edge collaborative artificial intelligence scheduling system with receipt type auditing and structure self-repairing functions

Abstract

The invention discloses a cloud edge collaborative artificial intelligence scheduling system with receipt type auditing and structure self-repairing functions, and belongs to the field of computers, artificial intelligence and cloud edge collaborative computing. The intelligent scheduling module is in communication connection with the edge computing node and the cloud computing platform; through strict one-in-one-out conservation check and sequence control, the task processing flow does not damage the existing structure, and no task is lost or repeated. The system automatically enters a correction process after detecting abnormity until inconsistency of all structures is eliminated, so that the processing process is kept complete and correct; the receipt log allows each decision and modification to be well documented. An auditor can reconstruct an event link through a receipt without depending on internal implementation. The Fen verification value is used as a fingerprint of a final result, and the output is further ensured to be verifiable and non-repudiated.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of computer, artificial intelligence and cloud edge collaborative computing, and particularly relates to a cloud edge collaborative artificial intelligence scheduling system with receipt type auditing and structure self-repairing functions. BACKGROUND

[0002] Audit difficulty: Existing cloud edge collaborative AI deployment lacks a perfect auditing mechanism. Traditional systems often only record coarse-grained logs or statistical summaries, and cannot provide step-by-step "receipts" to reproduce each decision and operation. Once an exception occurs (such as task loss or sequence disorder), it is difficult for operation and maintenance personnel to trace the problem source according to limited logs, and the credibility and verifiability of system behavior are insufficient.

[0003] Queue and cache correctness problem: In cloud edge collaborative processing, the consistency of task queues and caches often depends on empirical configuration. For example, when the load of an edge node is too high, it may batch transfer unfinished tasks to the cloud, but lacks order and conservation checks on the transfer process. This may lead to repeated processing or omission of tasks. In addition, if the cache data is reused without strict verification, it may provide outdated or unauthorized data to users, disrupting the structural correctness of the system.

[0004] Dependence on threshold and heuristic scheduling: Many existing solutions use threshold or heuristic rules for cloud edge scheduling, such as transferring tasks when CPU utilization exceeds a certain percentage. However, such static thresholds are difficult to adapt to dynamic changes and often require manual parameter tuning. More importantly, most heuristic strategies lack strict verification of the effect of each scheduling modification, which may trigger multiple adjustment operations (such as frequent task ownership switching) in a short period of time, making system behavior difficult to predict and audit. In summary, existing technologies lack a fine-grained and controllable mechanism to prove convergence to ensure structural correctness and reliable auditing during cloud edge collaboration. SUMMARY

[0005] The present application aims to overcome the above shortcomings and provide a cloud edge collaborative artificial intelligence scheduling system with receipt type auditing and structure self-repairing functions, which realizes structural correctness guarantee and receipt type auditing of task processing flow.

[0006] Technical solution: To solve the above technical problems, according to one aspect of the present application, more specifically, a cloud edge collaborative artificial intelligence scheduling system with receipt type auditing and structure self-repairing functions, order and conservation check: strict order control and conservation verification mechanism is introduced to ensure that tasks are not out of order and lost during transmission and processing between edge and cloud. In other words, each task entering the system has a strict corresponding output or saving, without redundant copies or omissions, realizing the conservation of queue and processing flow.

[0007] Single correction strategy: For detected structural abnormalities (e.g. task order conflicts or duplicate processing), the scheduling module only allows one correction action per cycle, eliminating simultaneous multiple changes. The invention presets the priority order of correction actions (denoted as G>Fr>Fd), ensuring that the system is always adjusted with the necessary correction of the highest priority. For example, global order correction (G) is performed first, if there is no order problem, resource fairness correction (Fr) is checked, and then duplicate data elimination (Fd) is processed. The single-step correction principle makes the system converge steadily to the correct state in each iteration, avoiding the mutual influence of multiple operations.

[0008] Receipt-style audit output: All scheduling decisions and state changes of the system are output in the form of text receipts (TXT). After each correction action, the system generates a receipt entry containing key parameters such as the value of the indicator involved in the current step, the type and identifier of the operation, etc. All receipts use natural number records in plain text, which can be audited without complex log analysis. The final output contains a deterministic Fence value as a summary check, which can verify the integrity and correctness of the entire receipt chain through a simple algorithm (such as summation check). Since the calculation process of the Fence value is fixed and does not depend on random hashing, the audit results of this system can be repeatedly verified, eliminating the possibility of tampering.

[0009] Through the above scheme, the invention ensures the efficiency of cloud-edge collaborative computing while achieving the goals of structural correctness, gradual repairability, and full-process auditability of task processing.

[0010] The beneficial effects of the cloud-edge collaborative artificial intelligence scheduling system with receipt-style audit and structural self-repairing function of the invention are:

[0011] Structural correctness guarantee: Strict one-in-one-out conservation checks and order controls ensure that task processing flows do not destroy existing structures and there is no task loss or duplication. The system automatically enters the correction process upon detecting abnormalities until all structural inconsistencies are eliminated, thereby maintaining the integrity and correctness of the processing process.

[0012] Audit transparency: Receipt-style logs provide evidence for every decision and modification. Auditors can reconstruct the event chain without relying on internal implementation. The Fence check value as the "fingerprint" of the final result further ensures that the output is verifiable and undeniable.

[0013] Gradual monotonic convergence: The single correction strategy combined with strict potential anomaly measurement (μ value) ensures that the system state improves monotonically. Mathematical proof shows that after each correction action, the total amount of potential anomalies Δμ=1, i.e. the deviation is reduced by one unit each step, and after a finite number of steps, the system will converge to a stable state. Compared with schemes that rely on threshold adjustments, the convergence process of this system is deterministic and does not require human intervention.

[0014] Avoid manual parameter tuning: As it does not rely on experience threshold triggering, the system can automatically adjust under various load conditions. The scheduling logic reacts to the structural bias detected in real time, without the need for manual setting of complex parameters, improving robustness and adaptability.

[0015] Fairness and performance: By recording resource usage and delay distribution indicators in the receipt, the system can quantify the fairness of each task processing (such as evaluating using the Gini coefficient). While ensuring fair scheduling, the system optimizes overall performance through cloud-edge division and intelligent routing. Test results show that in typical scenarios, task uplink traffic, median response time, and other indicators have improved significantly (see Appendix Figure 11 ).

[0016] In summary, the cloud-edge collaborative AI scheduling system proposed by the present application not only solves the problems of auditing difficulty and structural errors in the prior art, but also has the characteristics of high performance and high reliability, and can be widely applied to artificial intelligence scenarios that require cloud-edge collaborative processing and strict correctness and auditability. BRIEF DESCRIPTION OF DRAWINGS

[0017] The present application will be further described in detail below in conjunction with the drawings and specific implementation methods.

[0018] Figure 1 is a schematic diagram of the architecture of a typical artificial intelligence computing system.

[0019] Figure 2 is a schematic diagram of the basic architecture of an FPGA.

[0020] Figure 3 is a schematic diagram of the concept of dynamic reconfiguration of the FPGA part.

[0021] Figure 4 is a block diagram of the system architecture of an embodiment of the present application.

[0022] Figure 5 is a schematic diagram of the hardware architecture for implementing dynamic reconfiguration within an FPGA, showing the process of the scheduling module obtaining information and making decisions on task allocation.

[0023] Figure 6 is a schematic diagram of the typical structure of a convolutional neural network.

[0024] Figure 7 is a schematic diagram of the timeline of parallel task execution in the double RR region.

[0025] Figure 8 is a performance and energy consumption comparison chart of the system and other solutions.

[0026] Figure 9 is a schematic diagram of the software and hardware layered structure of an FPGA heterogeneous computing system.

[0027] Figure 10 Application diagram of the system of the present application in a cloud-edge collaborative computing environment.

[0028] Figure 11 Performance statistical result diagram of the system of the present application in a typical deployment scenario. DETAILED DESCRIPTION

[0029] Hereinafter, the present application will be described in detail with reference to the accompanying drawings and embodiments. It should be noted that the embodiments in the present application and the features in the embodiments can be combined with each other without conflict.

[0030] In order to make the technical scheme of the present application clearer, the present application will be further described in detail below with reference to the accompanying drawings and specific embodiments.

[0031] Reference Figures 1-11 A cloud-edge collaborative artificial intelligence scheduling system with receipt type audit and structure self-repairing function, the overall architecture is as shown in Figure 1 The system of the present application includes a cloud computing platform and a plurality of edge computing nodes, which are connected and work cooperatively through a network. The cloud computing platform is provided with an intelligent scheduling module and a supervision committee (LoL Council) module, which are used for global task allocation decision and audit supervision; each edge node is responsible for processing tasks nearby and coordinating with the cloud through a lightweight agent. The whole system communicates through a standard interface protocol, ensuring module decoupling and compatibility.

[0032] Intelligent scheduling module: the scheduling module is the core of the system, which is responsible for monitoring the task queue and the system state, and executing the scheduling algorithm to determine the execution location of the task in the cloud or the edge. Unlike traditional scheduling, the scheduling algorithm of the present system has a built-in structure correctness checking mechanism: in addition to the conventional task allocation logic, the scheduling module continuously probes the window (such as fixed time interval or specific event trigger), checks whether there is a structure anomaly (such as unclosed task dependency or repeated execution) in the system. Whenever entering the probe window and detecting an anomaly, the scheduling algorithm selects a single corrective action according to the predetermined priority and executes it. Once the correction is executed, a receipt entry is generated to record the details and results of the action, and the window is exited to wait for the next cycle. Since the "door" control logic is placed outside the loop (i.e. "Door outside"), as long as the anomaly is detected and the correction condition is met, each window will execute an adjustment once, and there is no blocking situation that requires multiple conditions to be met at the same time, thereby ensuring the continuous advancement of the system. This design guarantees the property of Δμ=1: each round of adjustment reduces the remaining anomaly count μ of the system by 1, achieving strict monotonic convergence.

[0033] Route policy module: For network routing in cloud-edge collaboration, the present application provides a route policy module that combines policy rules and network situation to select the optimal path for a task. This module formulates routing policies according to the task's goal (e.g. requiring a specific service from the cloud or collaboration between edge nodes), and ensures that the routing decision complies with overall structural correctness requirements (e.g. no loops or unauthorized paths are introduced). The policies can include rules such as preferring low-latency links or local preference, and the module will update the task's data flow direction accordingly after making the scheduling decision.

[0034] SRv6 segment rewriting module: The present system uses SRv6 (IPv6 segment routing) technology to implement the specific encapsulation of the above routing policies. The SRv6 segment rewriting module encodes the task packet header into the corresponding segment routing information according to the path determined by the route policy module. For example, if the task needs to be processed by edge node X first and then go to cloud data center Y, the module will write the SRv6 segment list representing X and Y in the data packet. The supporting nodes in the network direct the forwarding accordingly, thus implementing policy-based routing. Each SRv6 segment update action also generates a receipt, including the routing segment list and policy ID, to audit whether the selection of the network path is correctly executed. Through this mechanism, data can still be strictly tracked when transmitted in a complex topology, ensuring that the task follows the established policy and the path decision process is transparent and auditable.

[0035] Cache authorization adapter: As shown in Figure 4 , the present application adds a cache authorization adapter between the cache systems of the edge and the cloud, which is used to control the use and consistency of cached data. Traditional cache hits directly return may result in the provision of expired or unauthorized data; the adapter of the present application performs a secondary check on each cache hit, including: (1) whether the data is still fresh, avoiding the use of outdated cache when the source data is updated or the related task is repeatedly executed; (2) whether the requester has the right to obtain the cache result. The adapter decides whether to release the cache content by querying the permission token of the task context or checking the receipt serial number. If the check fails, it is forced to switch to the normal task processing flow instead of directly returning the cache result, thus ensuring that even if the cache is enabled, the order and correctness of task processing will not be compromised. The adapter itself also outputs a receipt to record the cache authorization result (such as "cache hit and authorization passed" or "cache hit but rejected, switch to normal execution"), ensuring that the cache behavior is clearly visible in the audit.

[0036] Token Verification Module: In cloud-edge collaborative systems, tasks and their results need to be transmitted between multiple nodes. To prevent impersonation, replay attacks, and other issues, this invention introduces a token verification mechanism. Each task request and intermediate result carries a unique token (e.g., a cryptographically based signature or sequence number). The token verification module in the system is responsible for verifying the token at key interaction points. Figure 5 As shown, when edge nodes send partial results to the cloud for merging, the cloud checks the validity of the token and whether it matches the expected task before processing. Only content with successful token verification is included in subsequent calculations; if verification fails, an anomaly reporting and correction process is triggered (e.g., recording a receipt and marking the task as needing rescheduling). The token verification module ensures that all data and commands entering the system process are legitimate, preventing structural damage caused by unclear identities or disordered sequences.

[0037] Committee and Postcard Mechanism: To enhance global auditing and multi-module coordination, this invention provides a "LoL Committee" (Supervisory Committee) module. This module can be deployed in the cloud, acting as a supervisor to perform macro-level auditing and collaborative control of system operation. Each edge node and cloud sub-module periodically sends status "postcards" (Councilpostcards) to the committee—brief reports containing summaries of the module's recent actions, resource utilization, and local receipt statistics. The committee module collects all postcards and comprehensively analyzes the overall system status, such as checking whether each module adheres to the "single correction" principle and whether there are inconsistencies in cross-module relationships. If the committee detects abnormal trends (e.g., an edge node repeatedly sending duplicate correction postcards, potentially indicating a local convergence problem), it can trigger a high-level alert or instruct the scheduling module to take global measures (such as temporarily suspending the allocation of new tasks to that node). The committee itself also maintains a global receipt log to record its decisions and key information from received postcards, forming a "LoL ledger." Ultimately, the committee can combine the receipts from each module to calculate the total Fence value for the entire system, serving as audit evidence confirming the completion of the overall operation. Through the committee mechanism, the system achieves collaborative auditing of multiple sub-processes or "seats," ensuring that audit evidence remains centralized and consistent even in large-scale distributed deployments.

[0038] Fair receipts and resource balancing: such as Figure 7As shown, this invention emphasizes the fairness of task scheduling and quantifies and reflects this fairness through receipts. When recording each task processing event, the system includes key performance indicators for that task in the receipt, such as completion time, waiting latency, and bandwidth / CPU usage. With the accumulation of numerous receipts, the scheduling module or committee can periodically calculate the fairness indicators of the current task scheduling, such as calculating the Gini coefficient or other fairness measures based on the distribution of task waiting times. If a fairness indicator deteriorates within a certain period (e.g., an increased Gini coefficient indicates uneven resource allocation), the system can determine that there is a potential scheduling bias and correct it by adjusting strategies (e.g., increasing the priority of tasks that have not received resources for a long time in subsequent decisions). These fairness-related adjustments also follow the principle of single correction, using fine-grained changes to avoid drastic fluctuations. Finally, after each task is completed, a "fair receipt" is generated as additional information about its processing result, listing the task's ranking in the entire queue, its fair allocation, etc., for auditing reference. Experimental statistics show that this system can maintain a low fairness Gini coefficient (e.g., around 0.20, see...). Figure 11 The table shows an improvement in fair allocation compared to traditional heuristic scheduling.

[0039] Exploratory Window and Single-Step Convergence: The core scheduling loop of this system operates based on the exploratory window mechanism. Typically, the exploratory window can be triggered periodically (e.g., once per second) or event-driven (e.g., immediately when the queue length surges). Regardless of the triggering method, the intelligent scheduling module performs the following operations each time the window opens: First, it collects key information about the current system (queue length, execution logs, receipt chain status, etc.). Then, it uses algorithms to detect structural anomalies, including Φ-type anomalies (unclosed dependencies or "cracks") and Ψ-type anomalies (redundant duplicates or "duplicates"). If no anomalies are found, the window closes, and the system continues normal task scheduling until the next window checks. If anomalies are found, the corresponding corrective action is selected and executed according to the predetermined priority G > Fr > Fd.

[0040] Class G (Global Order Correction): Corrects global sorting-related issues. For example, when a discrepancy is detected between the task execution order and the submission order, or when there is cross-node out-of-order behavior, a Class G operation is performed to restore the correct order (which may involve reordering a task or injecting a synchronization barrier, etc.).

[0041] Fr type (Fairness / Resource Correction): Resolves issues of unfair resource allocation or starvation. For example, if a task remains unprocessed for an extended period (violating fairness principles), the Fr operation may adjust its queue position or modify its priority parameters to ensure it can be processed in the next scheduling round, thereby maintaining overall fairness.

[0042] Fd (Deduplication and Rectification) class: Removes duplicate or redundant processing. For example, if the same data is detected to be processed repeatedly on different nodes, the Fd operation will terminate the redundant part, ensuring that the system does not perform duplicate work.

[0043] Each window executes at most one of the above three types of actions, and they are checked in a predefined priority order. After the correction is completed, the scheduling module immediately records the action with a receipt, such as "the Nth window performed Fr type correction, object task ID and its waiting time", etc. Then the current window round ends, and the system waits for the next trigger. Since each round strictly performs only one change, the system state's "potential" μ decreases by 1 each time. This process is as follows: Figure 10 As shown, this ensures that after a finite number of window cycles, all abnormal states are cleared (ultimately Φ = 0 and Ψ = 0, with no incomplete dependencies and no duplicate computations). It is important to emphasize that, due to the absence of internal dooroutside blocking, this correction process will not fall into deadlock by waiting for multiple conditions—as long as an abnormality exists and it is the window's turn, the system will act. This gives the entire scheduling non-gated characteristics, ensuring that execution is always actively progressing without idle waiting.

[0044] Receipts and Fence Output: As the above modules run, the system will generate a complete receipt chain throughout the task lifecycle. Each receipt uses a uniform TXT text format and includes:

[0045] Step ID: Identifies the scheduling loop or window number corresponding to the receipt.

[0046] Operation type: such as normal task allocation (Dispatch), cache verification (CacheAuth), order correction (G), fair correction (Fr), deduplication (Fd), etc., clearly record the main actions that occur in this step.

[0047] Parameters and impact: Record relevant parameter values, such as the task ID being corrected, the queue position before and after the adjustment, the change in the current Φ and Ψ counts (e.g., Φ↓1 or Ψ↓1), and the result of the action (success / failure).

[0048] Mirror index (mirror_ix): Used to mark which receipts correspond to changes to the same structural element. For each structural "gap" or duplicate, the system assigns a unique index, which is referenced by the relevant repair or removal receipts. This allows for the chaining of several receipts into a complete processing chain for the same issue during auditing.

[0049] Timestamp and signature: Each receipt is timestamped and can optionally be signed with an internal system key to prevent tampering (if higher security is required).

[0050] When all tasks are completed or the system enters an idle state, the intelligent scheduling module outputs the final receipt package, which includes a deterministic Fence field for summary verification. The Fence calculation formula is based on the natural number index in the receipt chain; for example, summing all mirror indices to obtain `txt_sum`, and recording the total number of receipt entries `seams_count`. The Fence field consists of these two values ​​(or a simple combination thereof), serving as a verification of the integrity of the entire receipt log: auditors can verify whether there are any missing or modified receipts by comparing `txt_sum` with the receipt details, as any minor tampering will lead to inconsistencies in the summation. It is worth noting that the Fence generation does not use complex algorithms such as hashing, but rather leverages the pure numerical nature of the receipts themselves to ensure determinism and repeatable calculation. In other words, different independent auditors will obtain the same result when calculating the Fence for the same batch of receipts, without relying on third-party tools. This TXT+Fence audit output is lightweight, efficient, and difficult to forge, greatly improving the system's trustworthy auditing level.

[0051] Example: Assume a smart transportation scenario where multiple roadside edge nodes collaborate with a cloud server to identify vehicles and pedestrians. During a task processing phase, an edge node misses a video frame from an upstream node due to network fluctuations, causing a delay in local analysis results (belonging to class Φ unclosed anomaly). The system detects a gap in the node's task queue and immediately triggers class G correction in the probing window: the missing frame is resent by a neighboring node or the cloud, and the edge node updates its results accordingly. This correction is recorded as a receipt (labeled as type G, associated with the lost frame ID, Φ↓1). The system continues to run, but the oversight committee finds that the node's processing delay is higher than other nodes, potentially indicating unfair resource allocation. Therefore, in a later window, the scheduling module executes class Fr correction: the priority of the node's subsequent tasks is increased to catch up, and this is recorded in the receipt (type Fr, task ID, improved waiting time, Ψ value unchanged). After several cycles of this operation, all camera nodes output recognition results on schedule without further anomalies, and the system finally outputs the Fence checksum and a complete list of receipts. Auditors can subsequently obtain these receipts and clearly reconstruct details such as which node was missing a frame at what time, how it was remedied, and how the delay was recovered. The Fence value verifies the integrity and reliability of the entire receipt chain. Therefore, it is evident that the system of this invention can guarantee structural correctness and auditable results even in complex real-time environments.

[0052] In summary, this invention achieves high efficiency, fairness, and verifiability in cloud-edge collaborative artificial intelligence computing through modular design and rigorous scheduling algorithms. The described embodiments are merely preferred examples; those skilled in the art should understand that various equivalent modifications can be made without departing from the principles of this invention, and these modifications also fall within the scope of protection of this invention.

[0053] The embodiments described above are merely illustrative of several implementations of the present invention, and while the descriptions are specific and detailed, they should not be construed as limiting the scope of the present invention. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of the present invention, and these modifications and improvements all fall within the scope of protection of the present invention. Therefore, the scope of protection of this patent should be determined by the appended claims.

Claims

1. A cloud-edge collaborative artificial intelligence scheduling system with receipt-based auditing and structural self-repairing functions, comprising at least one edge computing node, a cloud computing platform, and an intelligent scheduling module in communication with the edge computing node and the cloud computing platform, characterized in that: the intelligent scheduling module is configured to perform task scheduling and structural verification, detect sequence or conservation abnormalities in the task processing flow within a probe window period, trigger a correction action only once to adjust the task queue or processing flow when an abnormality is detected, and generate a corresponding text receipt (TXT) record; the system outputs an audit log containing all receipts and a deterministic Fence check value calculated from the receipts for the integrity and correctness verification of the task processing process.

2. The system of claim 1, wherein, The intelligent scheduling module includes routing. strategy (route) The policy submodule is used to formulate path policies between the cloud and the edge based on task requirements and network status. The path policies ensure that task data is routed to the target node according to predetermined rules and that the order of task processing is correct and secure.

3. The system of claim 1, wherein, The edge computing node and the cloud computing platform support SRv6 segment routing encapsulation, and the intelligent scheduling module utilizes SRv6 segment rewriting technology to encapsulate the route The policy is embedded in the task data packet, and a target segment list is inserted into the data packet header; the task is forwarded between the cloud-edge nodes according to the policy through the SRv6 encapsulation, and each segment routing update operation is recorded as a receipt for auditing.

4. The system of claim 1, wherein, The intelligent scheduling module performs queue conservation checks to ensure that the entry and removal of the task queue strictly correspond; when a task is repeated or missing, a correction is triggered once, including but not limited to terminating the execution of the repeated task or rescheduling the missing task, thereby ensuring the conservation of the task processing process, and the correction process and results are recorded in the form of receipts.

5. The system of claim 1, wherein, The audit log of the system only contains text receipts and Fence check values generated from the receipts, and does not rely on additional binary logs or hash signatures; each receipt records the details of a scheduling decision or correction action once, and the Fence check value is obtained by performing deterministic operations on predetermined fields in the receipt, which is used to verify the integrity and correctness of the receipt chain as a whole.

6. The system of claim 1, wherein, The cloud computing platform includes a supervision committee (LoLCouncil) module for collecting state summary information sent by the edge computing node and the intelligent scheduling module; the supervision committee module performs global consistency auditing on the running states of multiple nodes to detect whether there are structural abnormalities or resource allocation unfairness across nodes, and outputs global receipts or alerts, wherein the committee module also participates in the calculation of the Fence check value to reflect the global state.

7. The system of claim 1, wherein, The edge computing node is deployed with a cache An authorization adapter to perform authorization and freshness verification when a task request hits the local cache; only if the cache data passes verification does it return a result, otherwise the edge node processes the task as usual to ensure data correctness, the adaptation process and its results are logged as a receipt for auditability.

8. The system of claim 1, wherein, The cloud computing platform and the edge computing node are both configured with a token verification module for verifying the unique identification token attached to the task or data packet during task collaborative processing; when the token verification fails, the processing is rejected and the event is recorded as an abnormal receipt, thereby preventing unauthorized or out-of-order tasks from interfering with the normal process.

9. The system of claim 1, wherein, The intelligent scheduling module generates fairness receipts while recording task processing receipts, including indicators such as waiting time and resource occupancy ratio of each task; the system calculates the fairness degree index of resource allocation by analyzing the accumulated fairness receipts, and performs a single correction by adjusting the scheduling strategy when the index deviates from the preset range to improve overall fairness.

10. The system of claim 1, wherein, The scheduling algorithm of the intelligent scheduling module is executed based on a probe window cycle, ensuring that at most one correction action is executed in each window, and each correction action is executed according to a predetermined priority is selected; wherein the G-type action is used for global sequence adjustment, the Fr-type is used for resource fairness adjustment, and the Fd-type is used for repetition resolution; the algorithm ensures that the total amount of potential abnormalities of the system is reduced by one unit (Δμ=1) after each window, so that a correct and stable structure is reached after a limited number of iterations.

Images