Cloud edge-end collaborative architecture and task unloading method oriented to airport apron intelligent monitoring system

Abstract

The invention discloses a cloud side-end collaborative architecture and task unloading method for an airport apron intelligent monitoring system, and relates to the technical field of cloud side-end collaborative computing. Comprising a terminal layer, an edge server layer and a cloud server layer, the task unloading method of the system under the cloud side-end collaborative architecture is designed and comprises the steps that a task model, a time delay model, an energy consumption model and an accuracy rate model of the system are constructed, and a multi-objective optimization problem of time delay-energy consumption-accuracy rate is formed; modeling an optimization problem into a Markov decision process, and designing a state space, an action space and a reward function required by deep reinforcement learning; and designing a task unloading method based on multi-agent deep reinforcement learning, and finding an optimal task unloading strategy of the system. According to the method, the computing tasks can be dynamically, scientifically and reasonably distributed and cooperatively scheduled among the terminal, the edge and the cloud, so that the time delay, the energy consumption and the accuracy are comprehensively optimized, and the overall performance of the system is improved.

Description

Technical Field

[0001] This invention relates to the field of cloud-edge-device collaborative computing, and in particular to a cloud-edge-device collaborative architecture and task offloading method for an intelligent apron monitoring system. Background Technology

[0002] With the rapid development of the civil aviation industry and the in-depth advancement of smart airport construction, the apron operating environment is becoming increasingly complex, placing higher demands on safety, efficiency, and intelligence. As a key infrastructure for ensuring the safety of aircraft ground operations and improving the efficiency of apron resource scheduling, the apron intelligent monitoring system needs to process massive amounts of data generated from multiple sources of sensors in real time and quickly complete computationally intensive tasks such as target detection, behavior recognition, and conflict early warning.

[0003] Traditional apron monitoring systems typically employ a centralized processing architecture, uploading all sensed data to a central cloud platform for unified analysis and decision-making. However, this model has significant limitations: firstly, the sheer volume of raw data, such as video streams, in apron scenarios leads to a surge in network bandwidth pressure due to full uploading, making it difficult to meet the demands for low latency and high reliability; secondly, centralized cloud processing introduces significant communication latency, resulting in delayed responses to sudden and abnormal events and posing security risks.

[0004] To alleviate these problems, edge computing technology has been introduced into the field of apron monitoring. By deploying computing nodes at the network edge close to the data source, some computing tasks can be localized. However, existing edge solutions typically employ static task allocation strategies, lacking the ability to adapt to dynamic apron environments. When edge node resources are limited or encounter sudden high loads, problems such as task queuing, processing timeouts, or even service interruptions may still occur.

[0005] Furthermore, most current systems fail to effectively construct a three-tiered cloud-edge-device collaboration mechanism. Terminal devices only perform data acquisition functions, and there is a lack of efficient task offloading and scheduling strategies between the edge layer and the cloud, resulting in low overall resource utilization and low energy efficiency, making it difficult to support the comprehensive requirements of apron monitoring systems for real-time performance, robustness, and scalability.

[0006] Therefore, there is an urgent need to propose a new cloud-edge-device collaborative architecture for intelligent apron monitoring scenarios. This architecture, combined with a dynamic task offloading method, intelligently determines the task execution location based on multi-dimensional factors such as task characteristics, equipment load, and network status. This enables elastic scheduling and global optimization of computing resources, thereby improving the overall system performance and operating efficiency while ensuring monitoring accuracy and timeliness. Summary of the Invention

[0007] The purpose of this invention is to provide a cloud-edge-device collaborative architecture and task offloading method for an intelligent apron monitoring system. This method can intelligently decide the execution location of tasks based on the real-time operating environment and task requirements, thereby achieving low-latency, high-reliability, and high-energy-efficiency intelligent apron monitoring services.

[0008] To achieve the above objectives, the present invention provides the following solution:

[0009] The first aspect proposes a cloud-edge-device collaborative architecture for intelligent apron monitoring systems:

[0010] The architecture consists of a terminal device layer, an edge server layer, and a cloud server layer. The layers are connected by wired or wireless networks to form a distributed intelligent sensing and reasoning system.

[0011] At the terminal equipment layer, multiple high-definition surveillance cameras are deployed, evenly covering the main operating areas of the apron, to collect real-time dynamic video streams of aircraft, ground service vehicles, and personnel. Each camera acts as an independent data source, uploading raw video data to its corresponding edge server via a local area network. The terminal equipment also includes a workstation for apron controllers to receive alarm information and view analysis results.

[0012] At the edge server layer, multiple edge computing nodes are configured, with each edge server managing a group of cameras. The edge servers are equipped with high-performance GPUs, possessing strong local computing capabilities, enabling them to run lightweight multimodal large models for real-time video understanding tasks, including interactive behavior, status recognition, and anomaly detection. Simultaneously, the edge nodes are interconnected via a high-speed local area network, supporting cross-node task migration and load balancing, improving the overall system's fault tolerance and resource utilization.

[0013] At the cloud server layer, high-performance cloud servers deployed in data centers can run models with larger parameter sets to handle complex scenarios where edge nodes cannot determine their parameters, providing higher-precision semantic understanding and decision support. Furthermore, the cloud is also responsible for model training, version updates, historical data analysis, and system management and monitoring.

[0014] A task offloading method for a cloud-edge-device collaborative architecture for an apron intelligent monitoring system includes:

[0015] Step 1: The raw video stream data collected by the high-definition surveillance cameras deployed on the airport apron is first transmitted to the corresponding edge server (called the local edge server). The preprocessing module in the server uses a target detection model to detect the video frame by frame. Based on the detection results, the frame extraction rate is determined. The resolution of the extracted image frames is adjusted. Then, the consecutive image frames constitute a task, waiting for the offloading decision module to assign an execution node.

[0016] Step 2: The unloading decision module selects a suitable computing node based on the task's data volume, semantic complexity, and the current real-time status of the system (including the load of the cloud server, the load of each edge server, LAN and WAN transmission latency, and bandwidth). The specific selection is determined by a deep reinforcement learning-based agent. This agent does not use fixed rules but continuously learns and optimizes its strategy through interaction with the environment to achieve a dynamic balance between latency, system energy consumption, and accuracy.

[0017] Step 3: After the execution node is determined, the task will be transmitted to the corresponding device for reasoning of the visual language large model. The output reasoning and analysis results will be sent to the apron controllers for reference. At the same time, the processing results of the edge server also need to be uploaded to the cloud for data archiving and storage.

[0018] The preprocessing module includes:

[0019] The preprocessing module specifically needs to complete three tasks: First, dynamically adjust the image resolution, downsampling high-resolution input to low resolution as needed; second, implement intelligent frame extraction through a frame rate controller, which judges the scene activity and complexity based on the target detection model—reducing the sampling frequency when no key targets (aircraft, maintenance vehicles, etc.) appear, and maintaining a higher frame rate during high-dynamic operation phases such as aircraft taxiing and vehicle docking to ensure the integrity of the action sequence; third, evaluate the semantic complexity of the task based on the target detection results. Specifically: if the detected image frame contains neither aircraft nor maintenance vehicles, the task is considered a simple task; if the detected image frame contains only aircraft and no maintenance vehicles, the task is considered a general task; and if the detected image frame contains both aircraft and maintenance vehicles, the task is considered a difficult task.

[0020] The construction of the unloading decision module includes the following steps:

[0021] The second aspect proposes a task offloading method based on the aforementioned collaborative architecture, including the following steps:

[0022] S1: Construct a system model, including a task model, a latency model, an energy consumption model, and an accuracy model, forming a multi-objective optimization problem of "latency-energy consumption-accuracy".

[0023] S2: Model the optimization problem as a Markov decision process and design the state space, action space and reward function required for deep reinforcement learning.

[0024] S3: Design a task offloading method based on multi-agent deep reinforcement learning to find the optimal task offloading strategy for the system.

[0025] S4: Train a deep reinforcement learning agent and deploy it on each edge server to make offloading decisions.

[0026] Specifically, step S1 includes:

[0027] S1.1: Constructing the task model. Successive video frames are abstracted into computational task M. k Composed of triple M k ={v k , d k ,c k} indicates that, where v k The amount of data represented by the task will affect transmission latency; d k This represents computational load, which affects inference latency; c k This represents the complexity of the task, indicating the difficulty in understanding the video content, and can affect the accuracy of the model's inference.

[0028] S1.2: Constructing the latency model. The latency of task processing mainly includes four parts: (1) Inference latency: the time required for the task to be processed by the large model. (2) Waiting latency: the time required for the task to queue on the corresponding device and wait for the large model to infer. (3) Transmission latency: the time required for the task to be unloaded from the local edge server to other edge servers or cloud servers and for the data to be transmitted to the corresponding device. (4) Network latency: the fixed latency on the physical link during data transmission. The specific calculation formula is as follows:

[0029]

[0030] Wherein: T local T represents the latency of processing on the local edge server. edge T represents the latency of offloading to other edge servers for processing. cloud This represents the latency of unloading the data to the cloud server for processing. These represent the inference latency of the task on the local edge server, other edge servers, and cloud servers, respectively. These represent the waiting latency of the task on the local edge server, other edge servers, and cloud servers, respectively. These represent the transmission latency of a task being unloaded from a local edge server to another edge server or cloud server. These represent the network latency when a task is unloaded from a local edge server to another edge server or cloud server.

[0031] S1.3: Constructing an energy consumption model. The system's energy consumption mainly includes two parts: (1) Inference energy consumption: the energy consumed by the server during the processing of large model tasks. (2) Transmission energy consumption: the energy consumed by data transmission to the corresponding device during the process of the task being unloaded from the local edge server to other edge servers or cloud servers. The specific calculation formula is as follows:

[0032]

[0033] Among them: E local E represents the energy consumption processed by the local edge server. edge E represents the energy consumption of processing offloaded to other edge servers. cloud This represents the energy consumption of processing data offloaded to a cloud server. These represent the inference energy consumption of the task on the local edge server, other edge servers, and cloud servers, respectively. These represent the energy consumption during data transmission when a task is offloaded from a local edge server to another edge server or cloud server.

[0034] S1.4: Construct an accuracy model. This mainly depends on the accuracy of model inference on different devices. A certain correction amount is added to the baseline accuracy value, along with the task complexity c. k That's relevant. The specific calculation formula is as follows:

[0035]

[0036] Among them: Acc local Acc represents the accuracy of processing on a local edge server. edge Acc represents the accuracy of offloading processing to other edge servers. cloud This represents the accuracy of the unloading process to the cloud server. These represent the accuracy of the task on the local edge server (or other edge server) and on the cloud server, respectively. The impact of task complexity on the inference accuracy of large models.

[0037] S1.5: Construct the optimization objective function. For any time t, for the task M generated by the i-th camera... i,t Construct utility function U i,t The calculation formula is as follows:

[0038]

[0039] Where: w Acc w Lat w EngThese are non-negative weighting coefficients for accuracy, latency, and energy consumption, used to balance the importance of different performance metrics. i,t T i,t E i,t Representing task M respectively i,t The normalized accuracy, latency, and energy consumption.

[0040] Since multiple tasks occur simultaneously, it is also necessary to construct the total utility function U(i,t) of the system at time t, and the calculation formula is as follows:

[0041]

[0042] Where: N represents the number of cameras in the system, M represents the number of edge servers in the system, and λ and η represent non-negative weight coefficients. This represents the load (i.e., queuing time) of the m-th edge server at time t. This represents the average load of all edge servers at time t.

[0043] The overall optimization objective of the system is to find an optimal joint strategy while satisfying the constraints. To maximize the long-term cumulative utility of the system's discounts, i.e.:

[0044]

[0045] in: As a discount factor, Acc min T represents the minimum acceptable accuracy for each task. max This represents the maximum allowable latency for each task.

[0046] This optimization problem is a mixed-integer nonlinear programming problem, and the environment is highly dynamic. Therefore, traditional optimization methods fail, and a method based on deep reinforcement learning is required.

[0047] Furthermore, step S2 involves modeling the optimization problem as a Markov decision process and designing the state space, action space, and reward function required for deep reinforcement learning. The specific steps are as follows:

[0048] S2.1: Transform the multi-objective optimization problem constructed in S1.5 into a Markov decision process. The Markov decision process is divided into high-level decision and low-level decision. The high-level decision determines whether the task is executed at the offloading cloud server layer or at the edge layer. If the high-level decision allocates the task to the edge layer, then the low-level decision needs to be triggered to select a specific edge server for task execution.

[0049] S2.2: Construct the state space, action space, and reward function required for deep reinforcement learning, specifically:

[0050] The high-level intelligent agent focuses on a global resource view to determine the computational hierarchy; its state space is as follows:

[0051]

[0052] Where: c k d k These represent the task complexity and computational load, respectively. These are the average estimated latency times for the local edge, cloud, and edge layer, respectively. B is the corresponding queue length; E2C B E2E These refer to the bandwidth between edge clouds and between edge edges, respectively.

[0053] The low-level agent focuses on the edge layer resource view to determine which edge server to allocate resources to. Its state space is as follows:

[0054]

[0055] in: It is the estimated waiting time for the i-th edge server other than the local edge server; B is the queue length of the corresponding i-th edge server; E2E It refers to the bandwidth between edge servers.

[0056] The actions of a high-level intelligent agent are discrete binary choices, and its action space is:

[0057]

[0058] in: The representative selected a cloud server; This indicates the selection of an edge server.

[0059] The action of the low-level agent is to select one of M edge servers, and its action space is:

[0060]

[0061] in: Representative selects edge server e i .

[0062] High-level and low-level agents share a single global reward function:

[0063]

[0064] Furthermore, step S3: designing a task offloading method based on multi-agent deep reinforcement learning, specifically includes:

[0065] Based on the task requirements of the apron intelligent monitoring system, the Multi-Agent Proximal Policy Optimization (MAPPO) algorithm is selected to solve the constructed Markov decision process and find the optimal task offloading strategy for the system. The specific network architecture is as follows:

[0066] The high-level Actor network is a multilayer perceptron, with the input being the high-level state space and the output being a binary action probability distribution corresponding to the high-level actions; the low-level Actor network is a multilayer perceptron, with the input being the low-level state space and the output being an M-dimensional action probability distribution corresponding to the low-level actions; the Critic network adopts a centralized design, outputting the state value V(s) through the multilayer perceptron.

[0067] Furthermore, step S4: training the deep reinforcement learning agent, has the following specific steps:

[0068] A centralized training with decentralized execution (CTDE) architecture is adopted, and a mask update mechanism is introduced based on the MAPPO algorithm. The specific steps are as follows:

[0069] S4.1: Data Sampling. Each agent interacts with the environment, collecting trajectory data and storing it in the experience replay pool. Each data point includes: Where: s is the system and task state observed by the agent at the current moment, a high With a low These are the discrete action indices output by the high-level and low-level policy networks, respectively, logπ. high With logπ low , where are the log probabilities of the old policy corresponding to the above actions, used for subsequent calculation of the importance sampling ratio; r is the immediate reward value of the environmental feedback; and v is the Critic network's value assessment value of the current state, used for calculating the advantage function.

[0070] S4.2: Advantage Estimation. The advantage function at each time t is calculated using the Generalized Advantage Estimation (GAE) algorithm. The specific calculation process includes the following two sub-steps:

[0071] S4.2.1: Calculate the Temporal Difference Residual (TD Error). Based on the state value estimate output by the Critic network, calculate the TD error at the current time step. :

[0072]

[0073] Where: r t V(s) represents the immediate reward value from environmental feedback. t ) represents the state s at time t in the Critic network. t The state value is estimated, where γ is a discount factor used to balance the weights of immediate rewards and future long-term rewards, and d t This is the task end flag at time t. Its value is 1 if the task ends or the segment terminates, and 0 otherwise.

[0074] S4.2.2: Recursively calculate the Advantage Function (GAE), the formula is:

[0075]

[0076] Where λ is the GAE smoothing factor, used to balance bias and variance.

[0077] S4.3: High-level policy update. Calculate the high-level policy ratio. The high-level network parameters are updated using the clip loss function of PPO. The loss function formula for the high-level policy is as follows:

[0078]

[0079] in: The truncation parameter is a hyperparameter in the PPO algorithm used to limit the ratio. high The range of variation.

[0080] S4.4: Mask Update for Low-Level Strategies. Since low-level actions are ineffective when the high-level strategy selects "cloud," direct updates would introduce noise. Therefore, this invention first constructs a mask tensor K:

[0081]

[0082] Then calculate the original PPO loss of the low-level strategy. Since this loss includes all samples, a mask needs to be applied for filtering. Therefore, the loss function formula for the low-level strategy is:

[0083]

[0084] in: To prevent the division by zero of minute quantities.

[0085] S4.5: Entropy Regularization. To prevent the agent from prematurely converging to a local optimum when updating the policy network, this invention introduces an entropy regularization term into the total loss function of the Actor network update. The formula for calculating the entropy regularization loss function is as follows:

[0086]

[0087] Where: c ent B is the entropy coefficient, used to adjust the regularization strength; B is the batch size, i.e., the total number of samples used in each gradient update. It is information entropy, and its calculation formula is: , To prevent the division by zero of minute quantities.

[0088] S4.6: Calculate the total loss function updated by the Actor network. The formula is as follows:

[0089]

[0090] S4.7: Calculate the total loss function for the Critic network update and the Actor network update. The calculation formula is as follows:

[0091]

[0092] Where: c vf The value loss coefficient is used to balance Actor loss and Critic loss. This is the current value estimate. This is the actual discount report corresponding to the sample, which is usually derived by back-calculating the dominance function.

[0093] The trained Actor model of the agent will be deployed on each edge server to make offloading decisions.

[0094] The present invention discloses the following technical effects:

[0095] This invention provides a cloud-edge-device collaborative architecture and task offloading method for an intelligent apron monitoring system, which has the following advantages:

[0096] Reduce end-to-end processing latency: By processing time-sensitive tasks close to the terminal and edge, the latency of data upload and remote response is significantly reduced, meeting the stringent real-time requirements of apron monitoring.

[0097] Improve system resource utilization efficiency: Dynamically allocate computing load according to task characteristics and system status to avoid edge overload or idle cloud resources and achieve elastic collaboration of computing resources;

[0098] Enhanced system robustness and scalability: The cloud-edge-device layered architecture supports fault isolation and local autonomy. Even if some nodes fail, basic monitoring functions can still be maintained, and it is easy to scale horizontally by random field size.

[0099] Optimize energy consumption: Reduce unnecessary data transmission and redundant calculations by intelligent offloading, thereby reducing the overall system energy consumption. Attached Figure Description

[0100] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0101] Figure 1 Cloud-edge-device collaborative architecture diagram of the apron intelligent monitoring system;

[0102] Figure 2 Workflow diagram of a cloud-edge-device collaborative architecture intelligent apron monitoring system;

[0103] Figure 3 Flowchart of a task offloading method based on multi-agent deep reinforcement learning;

[0104] Figure 4 Performance comparison chart of task unloading methods. Detailed Implementation

[0105] The present invention will now be described in further detail with reference to the accompanying drawings and specific embodiments:

[0106] This invention provides a cloud-edge-device collaborative architecture for an intelligent apron monitoring system. The functions of the intelligent apron monitoring system include: using Visual Language Models (VLM) to understand and analyze videos captured by airport apron cameras, identifying aircraft and apron maintenance vehicles and their status, such as refueling trucks refueling aircraft and baggage trucks unloading cargo, and determining whether any abnormal situations have occurred, such as abnormal vehicle intrusion or collisions between aircraft.

[0107] The system architecture is as follows Figure 1As shown, the architecture consists of a terminal device layer, an edge server layer, and a cloud server layer. These layers are connected via wired or wireless networks, forming a distributed intelligent sensing and reasoning system. At the terminal device layer, multiple high-definition surveillance cameras are deployed, evenly covering the main operating areas of the apron, to collect real-time dynamic video streams of aircraft, ground service vehicles, and personnel. Each camera acts as an independent data source, uploading raw video data to its corresponding edge server via a local area network. The terminal devices also include apron controller workstations for receiving alarm information and viewing analysis results. At the edge server layer, multiple edge computing nodes are configured, with each edge server managing a group of cameras. The edge servers are equipped with high-performance GPUs (such as NVIDIA RTX A6000), possessing strong local computing capabilities and able to run lightweight multimodal large models (such as Qwen3-VL-8B) for real-time video understanding tasks, including interactive behavior, status recognition, and preliminary anomaly detection. Simultaneously, the edge nodes are interconnected via a high-speed local area network, supporting cross-node task migration and load balancing, improving the overall system's fault tolerance and resource utilization. At the cloud server layer, high-performance cloud servers (equipped with A800 GPUs) deployed in data centers can run the Qwen3-VL-32B model with a larger number of parameters to handle complex scenarios where edge nodes cannot be determined, providing higher-precision semantic understanding and decision support. In addition, the cloud is also responsible for model training, version updates, historical data analysis, and system management and monitoring.

[0108] The entire system dynamically allocates tasks through a computational offloading mechanism: when a video stream has high content complexity or the local edge load is too high, the system can automatically offload the task from the local edge server to other idle edge nodes, or further transmit it to the cloud for high-precision inference; conversely, under normal operating conditions, processing is prioritized locally to ensure low-latency response. This architecture achieves the goals of data processing nearby, elastic task allocation, and efficient resource utilization, meeting the stringent requirements of apron monitoring for real-time performance and reliability while fully leveraging the advantages of large-scale models in video understanding, providing a scalable and implementable technical path for smart airport construction.

[0109] The system's workflow is as follows Figure 2 As shown, the steps include:

[0110] Step 1: The raw video stream data collected by the high-definition surveillance cameras deployed on the airport apron is first transmitted to the corresponding edge server (called the local edge server). The preprocessing module in the server uses a target detection model to detect the video frame by frame. Based on the detection results, the frame extraction rate is determined. The resolution of the extracted image frames is adjusted. Then, the consecutive image frames constitute a task, waiting for the offloading decision module to assign an execution node.

[0111] Step 2: The unloading decision module selects a suitable computing node based on the task's data volume, semantic complexity, and the current real-time status of the system (including the load of the cloud server, the load of each edge server, LAN and WAN transmission latency, and bandwidth). The specific selection is determined by a deep reinforcement learning-based agent. This agent does not use fixed rules but continuously learns and optimizes its strategy through interaction with the environment to achieve a dynamic balance between latency, system energy consumption, and accuracy.

[0112] Step 3: After the execution node is determined, the task will be transmitted to the corresponding device for reasoning of the visual language large model. The output reasoning and analysis results will be sent to the apron controllers for reference. At the same time, the processing results of the edge server also need to be uploaded to the cloud for data archiving and storage.

[0113] This invention also provides a task offloading method based on multi-agent deep reinforcement learning, the process of which is as follows: Figure 3 As shown, the image data output by the preprocessing module, the object detection results, and the quantized video complexity index, together with the real-time operating status of the system (including GPU utilization, memory usage, local area network transmission latency, and cloud load of each edge server), constitute the decision input. A deep reinforcement learning-based agent is used to comprehensively determine which computing node should execute the current task. This agent does not use fixed rules but continuously learns and optimizes its strategy through interaction with the environment to achieve a dynamic balance between latency, system energy consumption, and accuracy.

[0114] The decision results point to three execution paths: if the task is simple and local edge resources are sufficient, it is processed directly on the corresponding local edge server; if the local load is too high but other edge nodes are idle, the task is migrated to a remote edge server for processing to avoid unnecessary cloud overhead; if the video content involves complex interactions or has high uncertainty (such as suspected violations), the data is uploaded to the cloud, and a high-precision model is called for detailed inference. Once the unloading decision is determined, the image frame data is routed to the designated computing node and loaded with the corresponding large visual language model for end-to-end semantic understanding. The model not only identifies target entities but also infers their operational status and behavioral intentions, such as determining whether "the refueling truck is docking with the aircraft," "whether the baggage conveyor belt is in operation," or "whether there are unauthorized personnel entering the restricted area." After inference, the system generates structured analysis results, including natural language descriptions, timestamps, and other information, and pushes them to the work terminals of apron controllers for manual review and emergency response. Meanwhile, data such as the execution path, actual time consumption, resource consumption, and model output quality of this task are recorded and fed back to the system status monitoring module to update the system operating environment status for the next round of decision-making, thus forming a closed-loop adaptive optimization mechanism. The entire process ensures high real-time performance while balancing computational efficiency and semantic understanding accuracy, providing intelligent and scalable technical support for safe apron operation.

[0115] The specific construction steps of the task offloading method based on multi-agent deep reinforcement learning are as follows:

[0116] S1: Construct a system model, including a task model, a latency model, an energy consumption model, and an accuracy model, forming a multi-objective optimization problem of "latency-energy consumption-accuracy".

[0117] S1.1: Constructing the task model. Successive video frames are abstracted into computational task M. k Composed of triple M k ={v k , d k ,c k} indicates that, where v k The amount of data represented by the task will affect transmission latency; d k This represents computational load, which affects inference latency; c k This represents the complexity of the task, indicating the difficulty in understanding the video content, and can affect the accuracy of the model's inference.

[0118] S1.2: Constructing the latency model. The latency of task processing mainly includes four parts: (1) Inference latency: the time required for the task to be processed by the large model. (2) Waiting latency: the time required for the task to queue on the corresponding device and wait for the large model to infer. (3) Transmission latency: the time required for the task to be unloaded from the local edge server to other edge servers or cloud servers and for the data to be transmitted to the corresponding device. (4) Network latency: the fixed latency on the physical link during data transmission. The specific calculation formula is as follows:

[0119]

[0120] Wherein: T local T represents the latency of processing on the local edge server. edge T represents the latency of offloading to other edge servers for processing. cloud This represents the latency of unloading the data to the cloud server for processing. These represent the inference latency of the task on the local edge server, other edge servers, and cloud servers, respectively. These represent the waiting latency of the task on the local edge server, other edge servers, and cloud servers, respectively. These represent the transmission latency of a task being unloaded from a local edge server to another edge server or cloud server. These represent the network latency when a task is unloaded from a local edge server to another edge server or cloud server.

[0121] S1.3: Constructing an energy consumption model. The system's energy consumption mainly includes two parts: (1) Inference energy consumption: the energy consumed by the server during the processing of large model tasks. (2) Transmission energy consumption: the energy consumed by data transmission to the corresponding device during the process of the task being unloaded from the local edge server to other edge servers or cloud servers. The specific calculation formula is as follows:

[0122]

[0123] Among them: E local E represents the energy consumption processed by the local edge server. edge E represents the energy consumption of processing offloaded to other edge servers. cloud This represents the energy consumption of processing data offloaded to a cloud server. These represent the inference energy consumption of the task on the local edge server, other edge servers, and cloud servers, respectively. These represent the energy consumption during data transmission when a task is offloaded from a local edge server to another edge server or cloud server.

[0124] S1.4: Construct an accuracy model. This mainly depends on the accuracy of model inference on different devices. A certain correction amount is added to the baseline accuracy value, along with the task complexity c. k That's relevant. The specific calculation formula is as follows:

[0125]

[0126] Among them: Acc local Acc represents the accuracy of processing on a local edge server. edge Acc represents the accuracy of offloading processing to other edge servers. cloud This represents the accuracy of the unloading process to the cloud server. These represent the accuracy of the task on the local edge server (or other edge server) and on the cloud server, respectively. The impact of task complexity on the inference accuracy of large models.

[0127] S1.5: Construct the optimization objective function. For any time t, for the task M generated by the i-th camera... i,t Construct utility function U i,t The calculation formula is as follows:

[0128]

[0129] Where: w Acc w Lat w Eng These are non-negative weighting coefficients for accuracy, latency, and energy consumption, used to balance the importance of different performance metrics. i,t T i,t E i,t Representing task M respectively i,t The normalized accuracy, latency, and energy consumption.

[0130] Since multiple tasks occur simultaneously, it is also necessary to construct the total utility function U(i,t) of the system at time t, and the calculation formula is as follows:

[0131]

[0132] Where: N represents the number of cameras in the system, M represents the number of edge servers in the system, and λ and η represent non-negative weight coefficients. This represents the load (i.e., queuing time) of the m-th edge server at time t. This represents the average load of all edge servers at time t.

[0133] The overall optimization objective of the system is to find an optimal joint strategy while satisfying the constraints. To maximize the long-term cumulative utility of the system's discounts, i.e.:

[0134]

[0135] in: As a discount factor, Acc min T represents the minimum acceptable accuracy for each task. max This represents the maximum allowable latency for each task.

[0136] This optimization problem is a mixed-integer nonlinear programming problem, and the environment is highly dynamic. Therefore, traditional optimization methods fail, and a method based on deep reinforcement learning is required.

[0137] S2: Model the optimization problem as a Markov decision process and design the state space, action space and reward function required for deep reinforcement learning.

[0138] S2.1: Transform the multi-objective optimization problem constructed in S1.5 into a Markov decision process. The Markov decision process is divided into high-level decision and low-level decision. The high-level decision determines whether the task is executed at the offloading cloud server layer or at the edge layer. If the high-level decision allocates the task to the edge layer, then the low-level decision needs to be triggered to select a specific edge server for task execution.

[0139] S2.2: Construct the state space, action space, and reward function required for deep reinforcement learning, specifically:

[0140] The high-level intelligent agent focuses on a global resource view to determine the computational hierarchy; its state space is as follows:

[0141]

[0142] Where: c k d k These represent the task complexity and computational load, respectively. These are the average estimated latency times for the local edge, cloud, and edge layer, respectively. B is the corresponding queue length; E2C B E2E These refer to the bandwidth between edge clouds and between edge edges, respectively.

[0143] The low-level agent focuses on the edge layer resource view to determine which edge server to allocate resources to. Its state space is as follows:

[0144]

[0145] in: It is the estimated waiting time for the i-th edge server other than the local edge server; B is the queue length of the corresponding i-th edge server; E2E It refers to the bandwidth between edge servers.

[0146] The actions of a high-level intelligent agent are discrete binary choices, and its action space is:

[0147]

[0148] in: The representative selected a cloud server; This indicates the selection of an edge server.

[0149] The action of the low-level agent is to select one of M edge servers, and its action space is:

[0150]

[0151] in: Representative selects edge server e i .

[0152] High-level and low-level agents share a single global reward function:

[0153]

[0154] S3: Design a task offloading method based on multi-agent deep reinforcement learning to find the optimal task offloading strategy for the system.

[0155] Based on the task requirements of the apron intelligent monitoring system, the Multi-Agent Proximal Policy Optimization (MAPPO) algorithm is selected to solve the constructed Markov decision process and find the optimal task offloading strategy for the system. The specific network architecture is as follows:

[0156] The high-level Actor network is a multilayer perceptron, with input being the high-level state space described in S2.2, and output being a binary action probability distribution, corresponding to the high-level actions described in S2.2. The low-level Actor network is also a multilayer perceptron, with input being the low-level state space described in S2.2, and output being an M-dimensional action probability distribution, corresponding to the low-level actions described in S2.2. The Critic network adopts a centralized design, outputting the state value V(s) through the multilayer perceptron.

[0157] S4: Train a deep reinforcement learning agent and deploy it on each edge server to make offloading decisions.

[0158] A centralized training with decentralized execution (CTDE) architecture is adopted, and a mask update mechanism is introduced based on the MAPPO algorithm. The specific steps are as follows:

[0159] S4.1: Data Sampling. Each agent interacts with the environment, collecting trajectory data and storing it in the experience replay pool. Each data point includes: Where: s is the system and task state observed by the agent at the current moment, a high With a low These are the discrete action indices output by the high-level and low-level policy networks, respectively, logπ. high With logπ low , where are the log probabilities of the old policy corresponding to the above actions, used for subsequent calculation of the importance sampling ratio; r is the immediate reward value of the environmental feedback; and v is the Critic network's value assessment value of the current state, used for calculating the advantage function.

[0160] S4.2: Advantage Estimation. The advantage function at each time t is calculated using the Generalized Advantage Estimation (GAE) algorithm. The specific calculation process includes the following two sub-steps:

[0161] S4.2.1: Calculate the Temporal Difference Residual (TD Error). Based on the state value estimate output by the Critic network, calculate the TD error at the current time step. :

[0162]

[0163] Where: r t V(s) represents the immediate reward value from environmental feedback. t ) represents the state s at time t in the Critic network. t The state value is estimated, where γ is a discount factor used to balance the weights of immediate rewards and future long-term rewards, and d t This is the task end flag at time t. Its value is 1 if the task ends or the segment terminates, and 0 otherwise.

[0164] S4.2.2: Recursively calculate the Advantage Function (GAE), the formula is:

[0165]

[0166] Where λ is the GAE smoothing factor, used to balance bias and variance.

[0167] S4.3: High-level policy update. Calculate the high-level policy ratio. The high-level network parameters are updated using the clip loss function of PPO. The loss function formula for the high-level policy is as follows:

[0168]

[0169] in: The truncation parameter is a hyperparameter in the PPO algorithm used to limit the ratio. high The range of variation.

[0170] S4.4: Mask Update for Low-Level Strategies. Since low-level actions are ineffective when the high-level strategy selects "cloud," direct updates would introduce noise. Therefore, this invention first constructs a mask tensor K:

[0171]

[0172] Then calculate the original PPO loss of the low-level strategy. Since this loss includes all samples, a mask needs to be applied for filtering. Therefore, the loss function formula for the low-level strategy is:

[0173]

[0174] in: To prevent the division by zero of minute quantities.

[0175] S4.5: Entropy Regularization. To prevent the agent from prematurely converging to a local optimum when updating the policy network, this invention introduces an entropy regularization term into the total loss function of the Actor network update. The formula for calculating the entropy regularization loss function is as follows:

[0176]

[0177] Where: c ent B is the entropy coefficient, used to adjust the regularization strength; B is the batch size, i.e., the total number of samples used in each gradient update. It is information entropy, and its calculation formula is: , To prevent the division by zero of minute quantities.

[0178] S4.6: Calculate the total loss function updated by the Actor network. The formula is as follows:

[0179]

[0180] S4.7: Calculate the total loss function for the Critic network update and the Actor network update. The calculation formula is as follows:

[0181]

[0182] Where: c vf The value loss coefficient is used to balance Actor loss and Critic loss. This is the current value estimate. This is the actual discount report corresponding to the sample, which is usually derived by back-calculating the dominance function.

[0183] This invention uses simulation experiments to verify the performance of the proposed task offloading method HMAPPO (Hierarchical Multi-Agent Proximal Policy Optimization) based on multi-agent deep reinforcement learning. Key simulation parameters: number of cameras N=25, number of edge servers M=5, task data volume v. k The range is [2,4] MB, and the LAN bandwidth for communication between edge servers is B. E2E It is 1000Mbps, the WAN bandwidth B for communication between the edge and the cloud. E2C The speed is 100Mbps. The power consumption of the edge server is 300W, and the power consumption of the cloud server is 400W. The power consumption for data transmission between edge servers is 2W, and the power consumption for data transmission between the edge server and the cloud server is 5W. The baseline accuracy for task processing on the edge server is 0.85, and the baseline accuracy for processing on the cloud server is 0.95. The accuracy weight is w. Acc Delay weight w Lat Energy consumption weight w Eng The task proportions for the three difficulty levels (easy, normal, and hard) are 20%, 50%, and 30%, respectively, with 0.5, 0.4, and 0.1 being the highest.

[0184] In the simulation environment constructed in this invention, the proposed HMAPPO algorithm was compared with several other deep reinforcement learning methods, such as MADDPG (Multi-Agent Deep Deterministic Policy Gradient), DQN (Deep Q-Network), and IPPO (Independent Proximal Policy Optimization). Figure 4As shown, it can be observed that during the training process, the method proposed in this invention can converge first and obtain the highest reward value, with the advantages of fast training speed and good effect.

Claims

1. A cloud-edge-device collaborative architecture for an intelligent apron monitoring system, characterized in that: It includes a terminal device layer, an edge server layer, and a cloud server layer. These layers are connected via wired or wireless networks to form a distributed intelligent sensing and reasoning system. At the terminal equipment layer, multiple high-definition surveillance cameras are deployed to evenly cover the main operating areas of the apron, used to collect dynamic video streams of aircraft, ground service vehicles and personnel in real time; each camera serves as an independent data source, uploading raw video data to the corresponding edge server via a local area network; the terminal equipment also includes a workbench for apron controllers to receive alarm information and view analysis results; At the edge server layer, multiple edge computing nodes are configured, with each edge server responsible for managing a group of cameras. The edge servers are equipped with high-performance GPUs, which can run lightweight multimodal large models for real-time video understanding tasks, including interactive behavior, status recognition, and anomaly detection. At the same time, the edge nodes are interconnected through a high-speed local area network, supporting cross-node task migration and load balancing. At the cloud server layer, high-performance cloud servers deployed in data centers are used to handle complex scenarios where edge nodes cannot be determined, providing higher-precision semantic understanding and decision support. In addition, the cloud is also responsible for model training, version updates, historical data analysis, and system management and monitoring.

2. The task offloading method for the cloud-edge-device collaborative architecture of the apron intelligent monitoring system as described in claim 1, characterized in that, Includes the following steps: Step 1: The raw video stream data collected by the high-definition surveillance cameras deployed on the airport apron is first transmitted to the corresponding edge server, which is called the local edge server. The preprocessing module in the server uses a target detection model to detect the video frame by frame. Based on the detection results, the frame extraction rate is determined. The resolution of the extracted image frames is adjusted. Then, the consecutive image frames constitute a task, waiting for the offloading decision module to assign an execution node. Step 2: The unloading decision module will select a suitable computing node based on the data volume, semantic complexity, and real-time status of the current system. The specific selection is determined by an agent based on deep reinforcement learning. This agent does not use fixed rules, but learns and optimizes its strategy by interacting with the environment to achieve a dynamic balance between latency, system energy consumption, and accuracy. Step 3: After the execution node is determined, the task will be transmitted to the corresponding device for reasoning of the visual language large model. The output reasoning and analysis results will be sent to the apron controllers for reference. At the same time, the processing results of the edge server also need to be uploaded to the cloud for data archiving and storage.

3. The task offloading method for a cloud-edge-device collaborative architecture for an apron intelligent monitoring system according to claim 2, characterized in that, The preprocessing module includes: The preprocessing module specifically needs to complete three tasks: First, dynamically adjust the image resolution, downsampling high-resolution input to low resolution as needed; second, implement intelligent frame extraction through a frame rate controller, which judges scene activity and complexity based on the target detection model, reducing the sampling frequency when no key targets appear in the scene, and maintaining a high frame rate during the height-matching dynamic operation stage to ensure the integrity of the action sequence; third, evaluate the semantic complexity of the task based on the target detection results. Specifically: if the detected image frame contains neither an aircraft nor a maintenance vehicle, the task is considered a simple task; if the detected image frame contains only an aircraft and no maintenance vehicle, the task is considered a general task; and if the detected image frame contains both an aircraft and a maintenance vehicle, the task is considered a difficult task.

4. The task offloading method for the cloud-edge-device collaborative architecture of an intelligent apron monitoring system according to claim 2, characterized in that, The construction of the unloading decision module includes the following steps: S1: Construct a system model, including a task model, a latency model, an energy consumption model, and an accuracy model, forming a multi-objective optimization problem of "latency-energy consumption-accuracy"; S2: Model the optimization problem as a Markov decision process and design the state space, action space and reward function required for deep reinforcement learning; S3: Design a task offloading method based on multi-agent deep reinforcement learning and find the optimal task offloading strategy for the system. S4: Train a deep reinforcement learning agent and deploy it on each edge server to make offloading decisions.

5. The task offloading method for a cloud-edge-device collaborative architecture for an apron intelligent monitoring system according to claim 4, characterized in that, S1 includes: S1.1: Constructing the task model; consecutive video frames are abstracted into computational task M. k Composed of triple M k ={v k , d k , c k } indicates that, where v k The amount of data represented by d will affect transmission latency; k This represents computational load, which affects inference latency; c k This represents the complexity of the task, characterizing the difficulty of understanding the video content, and will affect the accuracy of the model's inference. S1.2: Constructing a latency model; The latency of task processing mainly includes four parts: (1) Inference latency: The time required for the task to be processed by the large model; (2) Waiting latency: The time required for the task to queue on the corresponding device and wait for the large model to infer; (3) Transmission latency: The time required for the task to be unloaded from the local edge server to other edge servers or cloud servers and for the data to be transmitted to the corresponding device; (4) Network latency: The fixed latency on the physical link during data transmission; The specific calculation formula is as follows: ； Wherein: T local T represents the latency of processing on the local edge server. edge T represents the latency of offloading to other edge servers for processing. cloud This represents the latency of unloading the data to the cloud server for processing. These represent the inference latency of the task on the local edge server, other edge servers, and cloud servers, respectively. These represent the waiting latency of the task on the local edge server, other edge servers, and the cloud server, respectively. These represent the transmission latency of a task being offloaded from a local edge server to another edge server or cloud server, respectively. These represent the network latency when a task is offloaded from a local edge server to another edge server or cloud server; S1.3: Construct an energy consumption model; The system's energy consumption mainly includes two parts: (1) Inference energy consumption: The energy consumed by the server during the processing of large model tasks; (2) Transmission energy consumption: The energy consumed by data transmission to the corresponding device during the process of the task being unloaded from the local edge server to other edge servers or cloud servers; The specific calculation formula is as follows: ； Where: E local E represents the energy consumption processed by the local edge server. edge E represents the energy consumption of processing offloaded to other edge servers. cloud This represents the energy consumption of data offloaded to a cloud server for processing. These represent the inference energy consumption of the task on the local edge server, other edge servers, and cloud servers, respectively. These represent the energy consumption during data transmission when a task is offloaded from a local edge server to another edge server or cloud server. S1.4: Construct an accuracy model; depending on the accuracy of model inference on different devices, add a certain correction amount to the baseline accuracy value, along with the task complexity c. k The specific calculation formula is as follows: ； Among them: Acc local Acc represents the accuracy of processing on a local edge server. edge Acc represents the accuracy of offloading processing to other edge servers. cloud This represents the accuracy of the unloading process to the cloud server. These represent the accuracy of the task on a local edge server or other edge server and on a cloud server, respectively. The impact of task complexity on the inference accuracy of large models; S1.5: Construct the optimization objective function; for any time t, calculate the task M generated by the i-th camera. i,t Construct utility function U i,t The calculation formula is as follows: ； Where: w Acc w Lat w Eng These are non-negative weighting coefficients for accuracy, latency, and energy consumption, used to balance the importance of different performance metrics; Acc i,t T i,t E i,t Representing task M respectively i,t The normalized accuracy, latency, and energy consumption; Since multiple tasks occur simultaneously, the total utility function U(i,t) of the system at time t is also constructed, and the calculation formula is as follows: ； Where: N represents the number of cameras in the system, M represents the number of edge servers in the system, and λ and η represent non-negative weighting coefficients. This represents the load, or queuing time, of the m-th edge server at time t. This represents the average load of all edge servers at time t; The overall optimization objective of the system is to find an optimal joint strategy while satisfying the constraints. To maximize the long-term cumulative utility of the system's discounts, i.e.: ； in: As a discount factor, Acc min T represents the minimum acceptable accuracy for each task. max This represents the maximum allowable latency for each task.

6. The task offloading method for a cloud-edge-device collaborative architecture for an apron intelligent monitoring system according to claim 5, characterized in that, S2 includes: S2.1: Transform the multi-objective optimization problem constructed in S1.5 into a Markov decision process; the Markov decision process is divided into high-level decision and low-level decision. The high-level decision determines whether the task is executed at the offloading cloud server layer or at the edge layer. If the high-level decision allocates the task to be executed at the edge layer, then the low-level decision needs to be triggered to select a specific edge server for task execution. S2.2: Construct the state space, action space, and reward function required for deep reinforcement learning, specifically: The high-level intelligent agent focuses on a global resource view to determine the computational hierarchy; its state space is as follows: ； Where: c k d k These represent the task complexity and computational load, respectively. These are the average estimated latency times for the local edge, cloud, and edge layer, respectively. B is the corresponding queue length; E2C B E2E These refer to the bandwidth between edge clouds and between edges, respectively. The low-level agent focuses on the edge layer resource view to determine which edge server to allocate resources to. Its state space is as follows: ； in: It is the estimated waiting time for the i-th edge server other than the local edge server; B is the queue length of the corresponding i-th edge server; E2E It refers to the bandwidth between edge servers; The actions of a high-level intelligent agent are discrete binary choices, and its action space is: ； in: The representative selected a cloud server; This indicates the selection of an edge server; The action of the low-level agent is to select one of M edge servers, and its action space is: ； in: Representative selects edge server e i ; High-level and low-level agents share a single global reward function: 。 7. The task offloading method for a cloud-edge-device collaborative architecture for an apron intelligent monitoring system according to claim 6, characterized in that, The S3 design includes a task offloading method based on multi-agent deep reinforcement learning, which includes: Based on the task requirements of the apron intelligent monitoring system, a multi-agent near-end policy optimization algorithm is selected to solve the constructed Markov decision process, thereby finding the optimal task offloading strategy for the system. The specific network architecture is as follows: The high-level Actor network is a multilayer perceptron, with the input being the high-level state space and the output being a binary action probability distribution corresponding to the high-level actions; the low-level Actor network is a multilayer perceptron, with the input being the low-level state space and the output being an M-dimensional action probability distribution corresponding to the low-level actions; the Critic network adopts a centralized design, outputting the state value V(s) through the multilayer perceptron.

8. The task offloading method for a cloud-edge-device collaborative architecture for an apron intelligent monitoring system according to claim 4, characterized in that, The S4 training deep reinforcement learning agent includes: A centralized training and decentralized execution architecture is adopted, and a mask update mechanism is introduced based on the MAPPO algorithm. The specific steps are as follows: S4.1: Data sampling; Each agent interacts with the environment to collect trajectory data and stores it in the experience replay pool; Each data point includes: Where: s is the system and task state observed by the agent at the current moment, a high With a low These are the discrete action indices output by the high-level and low-level policy networks, respectively, logπ. high With logπ low , where are the log probabilities of the old policy corresponding to the above actions, used for subsequent calculation of importance sampling ratio; r is the immediate reward value of environmental feedback; and v is the Critic network's value assessment value of the current state, used for calculating the advantage function. S4.2: Dominance estimation; The dominance function at each time t is calculated using the Generalized Dominance Estimation (GAE) algorithm. The specific calculation process includes the following two sub-steps: S4.2.1: Calculate the temporal differential residual (TD); based on the state value estimate output by the Critic network, calculate the TD error at the current time step. : ； Where: r t V(s) represents the immediate reward value from environmental feedback. t ) represents the state s at time t in the Critic network. t The state value is estimated, where γ is a discount factor used to balance the weights of immediate rewards and future long-term rewards, and d t This is the task end flag at time t. Its value is 1 if the task ends or the segment terminates, and 0 otherwise. S4.2.2: Recursively calculate the dominance function GAE, the formula is: ； Where: λ is the GAE smoothing factor, used to weigh the bias and variance; S4.3: High-level strategy update; calculate high-level strategy ratio The high-level network parameters are updated using the clip loss function of PPO. The loss function formula for the high-level policy is as follows: ； in: The truncation parameter is a hyperparameter in the PPO algorithm used to limit the ratio. high The range of variation; S4.4: Mask update for low-level strategies; Since low-level actions are invalid when the high-level layer selects "cloud", direct updates would introduce noise. First, construct the mask tensor K: ； Then calculate the original PPO loss of the low-level strategy. The loss function formula for the low-level strategy is: ； in: To prevent tiny amounts from being divided by zero; S4.5: Entropy Regularization; An entropy regularization term is introduced into the total loss function of the Actor network update. The formula for calculating the entropy regularization loss function is as follows: ； Where: c ent B is the entropy coefficient, used to adjust the regularization strength; B is the batch size, i.e., the total number of samples used in each gradient update. It is information entropy, and its calculation formula is: , To prevent tiny amounts from being divided by zero; S4.6: Calculate the total loss function updated by the Actor network; the formula is as follows: ； S4.7: Calculate the total loss function of the Actor network update for the Critic network update; the calculation formula is as follows: ; Where: c vf The value loss coefficient is used to balance Actor loss and Critic loss. This is the current value estimate. This is the actual discount report corresponding to the sample, which is usually derived by back-calculation of the dominance function; The trained Actor model of the agent will be deployed on each edge server to make offloading decisions.

Images