Deep learning-based remote sensing monitoring full-process simulation system and optimization method thereof

Abstract

The invention relates to the technical field of remote sensing monitoring full-process simulation systems based on deep learning and optimization methods thereof, particularly discloses a remote sensing monitoring full-process simulation system based on deep learning and an optimization method thereof, and aims to solve the problems of high model calculation complexity, significant decision delay and difficulty in edge deployment under the condition of resource limitation. The system comprises a data acquisition and preprocessing module, a multi-scale feature extraction module, a resource perception decision engine, a dynamic model assembly module and a task execution and feedback module, and adaptively adjusts a calculation strategy through a resource state evaluation and dynamic model selection mechanism. The resource consumption is obviously reduced; and the response speed and deployment flexibility of the system in a real-time scene are improved.

Description

Technical Field

[0001] This invention belongs to the field of computer technology, specifically relating to a deep learning-based simulation system for the entire remote sensing monitoring process and its optimization method. Background Technology

[0002] Remote sensing monitoring technology, as a core field of Earth observation and spatial information science, is widely used in macro-level decision support such as environmental monitoring, disaster assessment, resource surveys, and urban planning. This technology acquires multi-dimensional information about the Earth's surface through platforms such as satellites and aerial drones, and relies on data processing, analysis, and interpretation models to transform raw data into applied knowledge, forming a complex technological system. Among these, a deep learning-based remote sensing monitoring full-process simulation system aims to automatically simulate and optimize the entire chain from data acquisition to information extraction through intelligent algorithms, thereby improving monitoring efficiency and accuracy.

[0003] In existing technologies, remote sensing monitoring full-process simulation systems typically employ predefined, computationally intensive deep learning models as the core agent to perform task planning and decision-making. However, such systems exhibit significant limitations when facing real-time or near-real-time application scenarios:

[0004] Their models have a large number of parameters and high computational complexity, making it difficult to perform effective resource trade-offs and adaptive optimization under limited computing, storage, and communication bandwidth resources. This directly leads to a significant increase in system decision-making latency, making it unable to meet the time-sensitive requirements of tasks such as emergency response. Furthermore, due to excessive resource consumption, such systems are often difficult to deploy and apply in practice on edge computing devices or resource-constrained platforms.

[0005] Therefore, in the context of resource-constrained real-time remote sensing monitoring applications, how to design a lightweight, efficient, and intelligent full-process simulation system that can adapt to resource constraints and make intelligent decisions has become a key technical challenge that urgently needs to be solved in this field. Summary of the Invention

[0006] The technical problem this invention aims to solve is the shortcomings of existing remote sensing monitoring full-process simulation systems under resource-constrained conditions, such as large number of model parameters, high computational complexity, significant decision delays, and difficulty in deployment on edge devices. It provides a deep learning-based remote sensing monitoring full-process simulation system and its optimization method. This system, by constructing a multi-level resource perception and adaptive decision-making framework, significantly reduces computational and communication overhead while ensuring monitoring accuracy, thereby improving the system's response speed and deployment flexibility in real-time or near-real-time application scenarios.

[0007] The technical solution of this invention is to construct a deep learning-based simulation system for the entire remote sensing monitoring process. This system includes a data acquisition and preprocessing module, a multi-scale feature extraction module, a resource-aware decision engine, a dynamic model assembly module, and a task execution and feedback module. The data acquisition and preprocessing module is responsible for receiving raw remote sensing data streams from satellites or airborne platforms, and performing radiometric calibration, atmospheric correction, and geometric fine correction on the data to generate standardized multispectral or hyperspectral data cubes.

[0008] The multi-scale feature extraction module is connected to the output of the data acquisition and preprocessing module. It uses a cascaded convolutional neural network structure to extract deep semantic features at different spatial resolutions from a standardized data cube. The cascaded structure contains three sequentially connected sub-networks, which correspond to global scene features, local ground feature contour features, and pixel-level fine features, respectively. The number of convolutional layers and filter size of each sub-network are configured differently according to its feature abstraction level.

[0009] The resource-aware decision engine monitors the system's available computing resources, memory usage, and network bandwidth in real time, and outputs the optimal computing strategy identifier for the current environment based on a preset resource status evaluation function. The resource status evaluation function comprehensively considers three key indicators: CPU core utilization, GPU memory availability, and network latency, and calculates the overall resource adequacy score of the system through a linear weighted model.

[0010] The dynamic model assembly module receives an optimal computational strategy identifier from the resource-aware decision engine and multi-level feature maps from the multi-scale feature extraction module. Based on the computational budget constraints indicated by the identifier, it selects and combines lightweight task-specific networks from a pre-trained sub-model library. This sub-model library stores five neural network architectures with different complexity and accuracy tradeoffs, each optimized for a specific remote sensing monitoring task.

[0011] The task execution and feedback module loads a lightweight task-specific network generated by the dynamic model assembly module, performs forward inference on the input multi-level feature maps, and outputs the final land cover classification map, change detection results, or target recognition boxes. Simultaneously, this module collects actual performance metrics during task execution, including inference time, peak memory usage, and task accuracy, and feeds these metrics back to the resource-aware decision engine to dynamically update the weight coefficients in the resource status evaluation function.

[0012] In a preferred embodiment of the present invention, the cascaded convolutional neural network structure in the multi-scale feature extraction module uses depthwise separable convolutions instead of standard convolution operations. Specifically, the global scene feature extraction sub-network contains four depthwise separable convolutional layers with filter counts of 32, 64, 128, and 256 respectively; the local feature contour extraction sub-network contains three depthwise separable convolutional layers, each with 128 filters; and the pixel-level fine feature extraction sub-network contains two depthwise separable convolutional layers with 64 filters. This design reduces the total number of model parameters by approximately 70% while maintaining feature representation capabilities, significantly reducing computational complexity.

[0013] Furthermore, the linear weighted model used in the resource-aware decision engine is specifically expressed as follows: the resource adequacy score equals the sum of three values: 0.4 multiplied by the normalized value of CPU core utilization, 0.35 multiplied by the normalized value of GPU memory remaining, and 0.25 multiplied by the normalized value of network latency. Specifically, the normalized value of CPU core utilization is 1 minus the ratio of actual utilization to maximum available utilization; the normalized value of GPU memory remaining is the ratio of remaining GPU memory to total GPU memory; and the normalized value of network latency is 1 minus the ratio of actual latency to maximum tolerable latency. The resource adequacy score is divided into three discrete intervals, corresponding to three resource states: high load, medium load, and low load, and mapped to three different optimal computing strategy identifiers.

[0014] Furthermore, the dynamic model assembly module executes different model selection strategies based on the three received optimal computation strategy identifiers. When the identifier indicates a high-load state, a binary neural network architecture with the fewest parameters and the fastest computation speed is selected. When the identifier indicates a medium-load state, a medium-complexity network architecture employing channel pruning and quantization techniques is selected. When the identifier indicates a low-load state, a high-precision network architecture retaining full-precision floating-point operations is selected. All pre-trained sub-models are transferred from the same large teacher model using knowledge distillation techniques to ensure consistency in output logic between models of different complexities.

[0015] Furthermore, the performance metric feedback mechanism in the task execution and feedback module employs a time-decay-based sliding window averaging algorithm. This algorithm assigns higher weights to performance metrics collected within the most recent 10 inference cycles, while the weights of metrics from earlier cycles decay exponentially. The updated weight coefficients are synchronized to the linear weighted model in the resource-aware decision engine every 100 inference cycles, enabling the system to adaptively respond to long-term drift and short-term fluctuations in the computing environment.

[0016] Furthermore, the system operates within a hierarchical scheduling framework. This framework comprises a task planning layer, a resource scheduling layer, and an execution monitoring layer. The task planning layer receives monitoring task instructions from users on an hourly basis and breaks them down into a series of executable sub-task sequences. The resource scheduling layer allocates appropriate computing nodes to each sub-task on a minutely basis based on real-time resource conditions. The execution monitoring layer collects the running status and task progress of each node on a secondly basis and triggers a resource reallocation process when anomalies or performance bottlenecks are detected.

[0017] Compared with the prior art, the beneficial effects of the present invention are as follows:

[0018] 1. This invention constructs an intelligent system capable of adaptively adjusting model complexity and computational strategy based on real-time computing resource conditions by introducing a resource-aware decision engine and a dynamic model assembly module. The system employs a cascaded structure of depthwise separable convolution and multi-scale feature extraction, significantly reducing the number of model parameters and computational overhead during the feature extraction stage.

[0019] 2. The resource status assessment function quantifies multi-dimensional resource indicators into a unified sufficiency score through a linear weighted model and maps it to a clear decision identifier, making the model selection process data-driven. The dynamic model assembly module, based on a pre-trained sub-model library and knowledge distillation technology, ensures the consistency of output results under different resource constraints.

[0020] 3. The task execution and feedback module continuously optimizes system parameters through a sliding window averaging algorithm, improving long-term operational stability. The hierarchical scheduling framework ensures resource efficiency and task reliability during concurrent execution of multiple tasks at the system level.

[0021] 4. This invention effectively solves the core contradictions faced by remote sensing monitoring full-process simulation systems in resource-constrained environments, namely high decision-making delay, large resource consumption, and difficulty in edge deployment, and significantly improves the practicality and reliability of the system in real-time application scenarios such as emergency response. Attached Figure Description

[0022] Figure 1 This is a schematic diagram of the overall technical architecture of the deep learning-based remote sensing monitoring full-process simulation system proposed in this invention.

[0023] Figure 2 This is a schematic diagram of the core principle framework of the multi-level resource perception and adaptive decision-making framework in this invention;

[0024] Figure 3 This is a logical flowchart of the multi-scale feature extraction module in this invention;

[0025] Figure 4This is a schematic diagram of the multi-level interaction relationship and data flow between the resource-aware decision engine and the dynamic model assembly module in this invention;

[0026] Figure 5 This is a schematic diagram illustrating the performance optimization principle of the task execution and feedback module in this invention. Detailed Implementation

[0027] Please refer to the attached document for the overall technical architecture of the deep learning-based remote sensing monitoring full-process simulation system. Figures 1 to 5 It consists of five core components: a data acquisition and preprocessing module, a multi-scale feature extraction module, a resource-aware decision engine, a dynamic model assembly module, and a task execution and feedback module. These modules work together in a strict logical order and according to the data flow to form a complete closed-loop adaptive system.

[0028] The data acquisition and preprocessing module is the input end of the entire system, responsible for receiving raw remote sensing data streams transmitted from satellite or airborne platforms. This module contains three main processing stages: a radiometric calibration subunit, an atmospheric correction subunit, and a geometrical fine correction subunit. The radiometric calibration subunit first performs sensor-level physical quantity conversion on the raw digital quantized values, converting pixel values ​​into surface reflectance or radiance values. This conversion process relies on calibration coefficient files provided by the sensor manufacturer. These coefficient files are stored in the system's local configuration database and are automatically loaded each time data is received.

[0029] The atmospheric correction subunit then applies an atmospheric radiative transfer model to eliminate the influence of atmospheric scattering and absorption on the surface reflection signal. This subunit employs a lookup table method based on the MODTRAN model, pre-calculating correction coefficients based on the solar elevation angle, observation zenith angle, and atmospheric parameters during imaging, significantly reducing the complexity of real-time calculations.

[0030] The final step of the geometric correction subunit is to perform spatial transformation on the image to eliminate geometric errors caused by platform attitude changes, terrain undulations, and sensor distortion. This subunit employs a quadratic polynomial correction model and a bilinear interpolation resampling algorithm to accurately register the image to the specified geographic coordinate system, generating a standardized multispectral or hyperspectral data cube. The entire preprocessing workflow ensures that the physical meaning of the output data is clear and the spatial location is accurate, laying the foundation for subsequent feature extraction.

[0031] The multi-scale feature extraction module connects to the output of the data acquisition and preprocessing module. Please refer to the appendix for its internal logic flow. Figure 3This module employs a cascaded convolutional neural network structure to extract deep semantic features with different levels of abstraction from a standardized data cube. The cascaded structure comprises three sequentially connected subnetworks: a global scene feature extraction subnetwork, a local feature contour extraction subnetwork, and a pixel-level fine-grained feature extraction subnetwork. Each subnetwork is configured differently in terms of the number of convolutional layers and filter size to adapt to feature learning needs at different scales.

[0032] The global scene feature extraction subnetwork is specifically responsible for capturing the overall structure and macroscopic patterns of the image. It contains four depthwise separable convolutional layers with filter counts of 32, 64, 128, and 256 respectively. Each convolutional layer is followed by a batch normalization layer and a modified linear unit activation function to accelerate training convergence and enhance nonlinear representation capabilities. The local feature contour extraction subnetwork focuses on extracting feature boundary and shape information at medium scales. It contains three depthwise separable convolutional layers, each with 128 filters. This subnetwork increases the receptive field while maintaining the spatial resolution of the feature map by adjusting the convolution stride and padding method.

[0033] The pixel-level fine-grained feature extraction subnetwork is dedicated to capturing pixel-level details and subtle variations. It comprises two depthwise separable convolutional layers, each configured with 64 filters. This subnetwork employs dilated convolutions to expand the receptive field without increasing the number of parameters, ensuring that detailed information is not overly smoothed. The entire cascaded structure replaces standard convolution operations with depthwise separable convolutions, reducing the total number of model parameters by approximately 70%, significantly lowering computational complexity and memory usage.

[0034] The resource-aware decision engine is the core of the system's intelligent scheduling. Please refer to the appendix for its multi-level interaction with the dynamic model assembly module. Figure 4 This engine continuously monitors the system's real-time operating status, specifically tracking three key metrics: CPU core utilization, GPU memory availability, and network bandwidth. CPU core utilization is obtained through performance counters provided by the operating system kernel, with a sampling frequency of 10 times per second.

[0035] The remaining GPU memory is obtained by querying the memory status data structure through the GPU application programming interface (API), and is also updated 10 times per second. Network bandwidth is indirectly estimated by sending probe packets to the control node and measuring the round-trip time, with the probe interval set to once every 5 seconds. These raw metrics are normalized before being input into the resource status evaluation function for calculation.

[0036] The resource status assessment function uses a linear weighted model to quantify multi-dimensional resource indicators into a unified resource adequacy score. Specifically, this linear weighted model states that the resource adequacy score equals the sum of three values: 0.4 multiplied by the normalized value of CPU core utilization, 0.35 multiplied by the normalized value of GPU memory availability, and 0.25 multiplied by the normalized value of network latency. The normalized value of CPU core utilization is defined as 1 minus the ratio of actual utilization to maximum available utilization, with the maximum available utilization preset at 95%.

[0037] The normalized value of remaining GPU memory is defined as the ratio of remaining GPU memory to total GPU memory. The normalized value of network latency is defined as 1 minus the actual latency to the maximum tolerable latency, with the maximum tolerable latency set to 1000 milliseconds based on the network type. The calculated resource adequacy score is divided into three discrete intervals, corresponding to high load, medium load, and low load states, respectively.

[0038] A score below 0.3 is classified as a high-load state, a score between 0.3 and 0.7 as a medium-load state, and a score above 0.7 as a low-load state. Each state interval is mapped to a unique optimal computation strategy identifier, which is a 32-bit integer that encodes the trade-off parameters between model complexity, computational accuracy, and inference speed.

[0039] The dynamic model assembly module receives the optimal computational strategy identifier from the resource-aware decision engine and multi-level feature maps from the multi-scale feature extraction module. Its core function is to assemble the optimal task-specific network based on real-time resource constraints. Internally, this module maintains a pre-trained sub-model library containing five neural network architectures with different complexity and accuracy tradeoffs. Each architecture has been optimized for specific remote sensing monitoring tasks, including land cover classification, change detection, and target recognition.

[0040] When the identifier output by the resource-aware decision engine indicates a high-load state, the module selects a binary neural network architecture with the fewest parameters and the fastest computation speed. This architecture quantizes weights and activation values ​​into 1-bit binary values ​​and uses XOR operations instead of floating-point multiplication, greatly reducing computational intensity and memory access bandwidth. When the identifier indicates a medium-load state, the module selects a medium-complexity network architecture that employs channel pruning and quantization techniques.

[0041] This architecture reduces model size and inference latency while maintaining high accuracy by removing less contributing output channels from convolutional layers and quantizing the remaining weights into 8-bit integers. When the identifier indicates a low-load state, the module chooses to retain a high-precision network architecture with full-precision floating-point operations. This architecture uses 32-bit floating-point numbers to represent weights and activation values, fully utilizing computational resources to achieve optimal monitoring accuracy. All pre-trained sub-models are transferred from the same large teacher model using knowledge distillation techniques.

[0042] The knowledge distillation process uses soft labels output by the teacher model as supervision signals, enabling student models of varying complexity to learn the rich feature representations and decision boundaries inherent in the teacher model, ensuring consistency in output logic across different models. Upon receiving the feature map and identifier, the dynamic model assembly module first retrieves the corresponding model configuration file based on the identifier, then loads the appropriate model weights from the sub-model library, and finally instantiates the complete inference graph structure in memory.

[0043] The task execution and feedback module loads a lightweight task-specific network generated by the dynamic model assembly module, performs forward inference on the input multi-level feature maps, and outputs the final analysis results. For the land cover classification task, the output is the class probability distribution for each pixel, which is normalized using the softmax function, and the class corresponding to the highest probability is taken as the classification result. For the change detection task, the output is the difference intensity map between the preceding and following temporal images, and a binary mask of the change region is generated through threshold segmentation.

[0044] For the target recognition task, the output consists of the bounding box coordinates and class confidence scores of potential targets, with redundant detection boxes removed using a non-maximum suppression algorithm. This module also collects actual performance metrics during task execution, including inference time, peak memory usage, and task accuracy. Inference time is the time interval from the start of model forward propagation to the end of result output, measured using a high-precision timer. Peak memory usage records the maximum memory allocated by the system during inference, obtained using a memory profiling tool. Task accuracy uses different evaluation metrics depending on the task type: overall accuracy for classification tasks, intersection-over-union ratio for change detection tasks, and average accuracy for target recognition tasks.

[0045] These performance metrics are encapsulated into structured feedback data packets and transmitted to the resource-aware decision engine. The feedback mechanism uses a time-decaying sliding window averaging algorithm to process these metrics. This algorithm maintains a circular buffer of length 10 to store performance metrics collected in the most recent 10 inference cycles. Each newly arrived metric is assigned a weight of 1, and the weights of metrics from earlier cycles decay exponentially with a decay factor of 0.85.

[0046] The algorithm calculates a weighted average as a reliable estimate of the current system performance and uses this estimate to update the weight coefficients in the resource state evaluation function every 100 inference cycles. For example, if recent inference times remain consistently high, the algorithm will automatically increase the weight of CPU core utilization in the resource adequacy score, prompting the system to favor models with lower computational complexity. This dynamic update mechanism enables the system to adaptively respond to long-term drift and short-term fluctuations in the computing environment, maintaining overall performance stability.

[0047] The system operates within a hierarchical scheduling framework, which comprises three management levels: a task planning layer, a resource scheduling layer, and an execution monitoring layer. The task planning layer receives monitoring task instructions from users on an hourly basis, submitted via a graphical user interface or application programming interface (API). This layer decomposes complex monitoring tasks into a series of executable sub-task sequences; for example, large-area monitoring is broken down into multiple standard-scale tile processing tasks.

[0048] Each subtask comes with metadata descriptions, including geographical scope, sensor type, processing algorithm, and quality requirements. The resource scheduling layer allocates suitable computing nodes to each subtask on a minute-by-minute basis based on real-time resource conditions. This layer maintains a global resource view, recording the CPU load, GPU utilization, remaining memory, and network bandwidth of each computing node. The scheduling algorithm employs a priority-based round-robin strategy, prioritizing the allocation of high-priority tasks to nodes with lower loads, while also considering data locality to reduce data transfer overhead.

[0049] The monitoring layer collects the running status and task progress of each node on a second-by-second basis. This layer detects node liveness through a heartbeat mechanism, monitors resource usage through performance counters, and tracks task completion through a progress reporting mechanism. When a node failure, performance bottleneck, or task timeout is detected, the monitoring layer immediately triggers a resource reallocation process, migrating the affected tasks to healthy nodes for continued execution. The entire hierarchical scheduling framework coordinates resource allocation and task execution through multi-granularity time periods, ensuring resource efficiency and task reliability in high-concurrency scenarios.

[0050] Please refer to the appendix for the core principle framework of the system. Figure 2 This demonstrates the data flow and control logic of multi-level resource awareness and adaptive decision-making. The data flow begins with data acquisition, followed by multi-scale feature extraction to form multi-level feature representations. Under the control of the resource awareness decision engine, the dynamic model assembly module custom-builds the inference network, and finally, the task execution module outputs the analysis results and closes the feedback loop. The entire process achieves dynamic matching between computational resources and model complexity, maximizing system efficiency while ensuring monitoring accuracy.

[0051] Please refer to the appendix for the performance optimization principles of the task execution and feedback module. Figure 5 This paper details the internal implementation of the sliding window averaging algorithm and weight update mechanism. Feedback data packets first enter the data parser to extract key performance indicator fields. After validity validation, these fields are sent to the sliding window manager. The manager maintains a fixed-size window buffer, filling the position of the oldest data with new data, keeping the window continuously sliding. The weighted calculator then reads all data within the window, applies an exponentially decaying weight function to calculate the contribution of each data point, and sums them to obtain the weighted average.

[0052] This average value is compared to a preset performance threshold. If the deviation exceeds 15%, a weight adjustment instruction is generated. This instruction is sent to the parameter update interface of the resource-aware decision engine, which then modifies the coefficient values ​​in the linear weighted model accordingly. For example, if the average inference time exceeds the threshold, the weight coefficient for CPU core utilization is increased from 0.4 to 0.45, making the system more sensitive to computing resources. The entire optimization process is fully automated, requiring no manual intervention, ensuring the system's adaptive robustness during long-term operation.

[0053] The depthwise separable convolutional operations of the multi-scale feature extraction module are accelerated at the hardware level using a dedicated tensor computation library. The four convolutional layers of the global scene feature extraction subnetwork are executed in parallel on the GPU, utilizing thread blocks and shared memory to optimize data access patterns. The local feature contour extraction subnetwork employs a pipelined approach, overlapping input data loading and convolution computation time. The pixel-level fine-grained feature extraction subnetwork utilizes the GPU's tensor cores to perform mixed-precision computation, further improving throughput. The output feature maps of all convolutional layers are L2-norm normalized to stabilize the training process and improve generalization ability. Feature maps are passed between different subnetworks via skip connections, ensuring effective gradient flow during backpropagation and avoiding the vanishing gradient problem.

[0054] The sub-model library of the dynamic model assembly module is stored on a high-speed solid-state drive, employing memory-mapped file technology to accelerate the model loading process. Each model file contains three parts: model structure definition, weight parameters, and metadata. The model structure definition uses an open neural network exchange format to ensure cross-platform compatibility. The weight parameters are stored in blocks with compression and dynamically decompressed to GPU memory during loading. The metadata records the model's input and output dimensions, computational complexity score, and accuracy metrics for quick retrieval by the assembly algorithm. When the system needs to switch models, the assembly module first preloads the target model into the cache, and then replaces the old model with the new model through atomic swap operations, achieving seamless switching without affecting the real-time data stream.

[0055] The linear weighted model coefficients of the resource-aware decision engine are initially determined through grid search and cross-validation. After system deployment, these coefficients are continuously optimized through a feedback module. The engine includes a coefficient update strategy unit responsible for evaluating the effectiveness of each weight adjustment. The strategy unit compares the system performance changes before and after the weight update; if the performance improvement exceeds 5%, the update is confirmed; otherwise, it reverts to the previous stable version. This conservative update strategy avoids system oscillations caused by frequent adjustments, ensuring the stability of the decision-making process. The engine also implements a resource prediction submodule, which predicts resource trends over a future period based on an autoregressive integral moving average model. The prediction results serve as auxiliary information in the generation of the optimal calculation strategy identifier, giving the system a certain degree of forward-looking decision-making capability.

[0056] The inference engine of the task execution and feedback module supports multiple backend acceleration libraries, including OpenML optimizations for the CPU and CUDA acceleration for the GPU. The engine automatically selects the optimal backend based on the current load and dynamically adjusts the number of parallel threads at runtime. For binary neural networks, the engine enables a dedicated bitwise operation kernel, converting convolution operations into bitwise AND and bitwise counting operations, greatly improving computational efficiency. For quantized models, the engine uses integer arithmetic units to perform convolutions, avoiding floating-point conversion overhead. For full-precision models, the engine activates the GPU's floating-point tensor cores to maximize computational throughput. This multi-backend adaptive mechanism ensures that models of varying complexity achieve optimal performance on the hardware.

[0057] The system's communication layer employs zero-copy technology and remote direct memory access mechanisms to reduce the number of times data is copied between user space and kernel space. Large-scale remote sensing data is directly loaded into the processing pipeline via memory-mapped files, and intermediate feature maps are transferred between different modules via shared memory. Control commands and feedback data are transmitted asynchronously via high-speed message queues to ensure real-time responsiveness. All communication links implement transport layer security encryption and message authentication code verification to ensure data security and integrity. The system also implements a fault tolerance manager that automatically triggers a retransmission mechanism or switches to a backup link when communication interruption or data corruption is detected.

[0058] The deep learning-based remote sensing monitoring full-process simulation system achieves efficient and stable operation in resource-constrained environments through the precise coordination and multi-level optimization of the aforementioned modules. The system transforms the traditional fixed computational paradigm into a dynamic adaptive one, balancing the trade-off between computational accuracy and efficiency through real-time resource awareness and model adjustment. The cascaded structure of deep separable convolutions and multi-scale feature extraction lays the foundation for low-overhead feature learning.

[0059] Resource status assessment functions and linear weighted models provide quantitative decision-making basis. Dynamic model assembly mechanisms ensure a match between model complexity and resource constraints. A task execution feedback loop drives continuous optimization of system parameters. A hierarchical scheduling framework guarantees the reliability and efficiency of multi-task management. These technical elements work together to enable the system to adapt to diverse deployment scenarios, from cloud servers to edge devices, demonstrating significant advantages, particularly in latency-sensitive applications such as emergency response and real-time monitoring.

Claims

1. A deep learning-based remote sensing monitoring full-process simulation system, characterized in that, include: The data acquisition and preprocessing module is used to receive raw remote sensing data streams from satellite or airborne platforms; The multi-scale feature extraction module, connected to the output of the data acquisition and preprocessing module, uses a cascaded convolutional neural network structure to extract deep semantic features at different spatial resolutions from a standardized data cube. The cascaded structure contains three sequentially connected sub-networks, corresponding to global scene features, local ground feature contour features, and pixel-level fine features, respectively. The resource-aware decision engine monitors the available computing resources, memory usage, and network transmission bandwidth of the system in real time, and outputs the optimal computing strategy identifier under the current environment based on the preset resource status evaluation function. The resource status evaluation function comprehensively considers three key indicators: CPU core utilization, GPU memory availability, and network latency, and calculates the overall resource adequacy score of the system through a linear weighted model. The dynamic model assembly module receives the optimal computation strategy identifier from the resource-aware decision engine and the multi-level feature map from the multi-scale feature extraction module. Based on the computation budget constraints indicated by the identifier, it selects and combines lightweight task-specific networks from the pre-trained sub-model library. The sub-model library stores five neural network architectures with different complexity and accuracy trade-offs. The task execution and feedback module loads a lightweight task-specific network generated by the dynamic model assembly module, performs forward inference on the input multi-level feature maps, and outputs land cover classification maps, change detection results, or target recognition boxes; at the same time, it collects actual performance indicators during task execution and feeds them back to the resource-aware decision engine.

2. The deep learning-based remote sensing monitoring full-process simulation system according to claim 1, characterized in that, The cascaded convolutional neural network structure in the multi-scale feature extraction module uses depthwise separable convolution instead of standard convolution operations; The global scene feature extraction subnetwork contains four depthwise separable convolutional layers with the following filter numbers: 32, 64, 128, and 256, respectively. The local feature extraction subnetwork contains three depth-separable convolutional layers, each with 128 filters. The pixel-level fine feature extraction subnetwork contains two depthwise separable convolutional layers and has 64 filters.

3. The deep learning-based remote sensing monitoring full-process simulation system according to claim 1, characterized in that, The linear weighted model used in the resource-aware decision engine is specifically expressed as follows: the resource adequacy score is equal to the sum of three values: 0.4 multiplied by the normalized value of CPU core utilization, 0.35 multiplied by the normalized value of GPU memory remaining, and 0.25 multiplied by the normalized value of network latency. Among them, the normalized value of CPU core utilization is 1 minus the ratio of actual utilization to maximum available utilization; the normalized value of GPU memory remaining is the ratio of remaining GPU memory to total GPU memory; and the normalized value of network latency is 1 minus the ratio of actual latency to maximum tolerable latency.

4. The deep learning-based remote sensing monitoring full-process simulation system according to claim 3, characterized in that, The resource sufficiency score is divided into three discrete intervals, corresponding to three resource states: high load, medium load, and low load, and mapped to three different optimal calculation strategy identifiers. A score below 0.3 is classified as a high load state, a score between 0.3 and 0.7 is classified as a medium load state, and a score above 0.7 is classified as a low load state.

5. The deep learning-based remote sensing monitoring full-process simulation system according to claim 4, characterized in that, The dynamic model assembly module executes different model selection strategies based on the three received optimal computation strategy identifiers; When the identifier indicates a high load state, choose the binary neural network architecture with the fewest parameters and the fastest computation speed. When the identifier indicates the load status, a medium-complexity network architecture using channel pruning and quantization techniques is selected; When the identifier indicates a low-load state, a high-precision network architecture that retains full-precision floating-point operations is selected.

6. The deep learning-based remote sensing monitoring full-process simulation system according to claim 5, characterized in that, The pre-trained sub-models were all obtained from the same large teacher model through knowledge distillation technology; The knowledge distillation process uses the soft labels output by the teacher model as supervision signals, enabling student models of different complexities to learn the feature representations and decision boundaries implied by the teacher model.

7. The deep learning-based remote sensing monitoring full-process simulation system according to claim 1, characterized in that, The performance indicator feedback mechanism in the task execution and feedback module adopts a time-decay-based sliding window averaging algorithm. The algorithm assigns higher weights to performance metrics collected in the most recent 10 inference cycles, while the weights of metrics from earlier cycles decay exponentially, with a decay factor set to 0.

85.

8. The deep learning-based remote sensing monitoring full-process simulation system according to claim 7, characterized in that, The sliding window averaging algorithm maintains a circular buffer of length 10 to store performance metrics collected in the last 10 inference cycles. Each newly arrived indicator is assigned a weight of 1, and the weights of indicators from earlier periods decay exponentially. The algorithm calculates a weighted average as a reliable estimate of the current system performance and uses this estimate to update the weight coefficients in the resource state evaluation function every 100 inference cycles.

9. The deep learning-based remote sensing monitoring full-process simulation system according to claim 1, characterized in that, The system operates entirely within a hierarchical scheduling framework. The hierarchical scheduling framework includes a task planning layer, a resource scheduling layer, and an execution monitoring layer. The task planning layer receives monitoring task instructions from users on an hourly basis and breaks them down into a sequence of executable subtasks. The resource scheduling layer allocates appropriate computing nodes to each subtask based on real-time resource conditions, on a minute-by-minute basis. The monitoring layer collects the running status and task progress of each node in seconds, and triggers a resource reallocation process when an anomaly or performance bottleneck is detected.

10. The deep learning-based remote sensing monitoring full-process simulation system according to claim 1, characterized in that, The actual performance metrics collected by the task execution and feedback module include inference time, peak memory usage, and task accuracy. Inference time is the time interval from the start of the model's forward propagation to the end of the result output, measured using a high-precision timer; The peak memory record shows the maximum memory capacity allocated by the system during inference, obtained through a memory profiling tool. Different evaluation metrics are used for task accuracy depending on the task type: overall accuracy is used for classification tasks, intersection-union ratio is used for change detection tasks, and average accuracy is used for target recognition tasks.

Images