Remote sensing image intelligent interpretation method and device based on kubernetes and electronic equipment

Abstract

This invention provides a Kubernetes-based intelligent interpretation method, apparatus, and electronic device for remote sensing images. The method includes: generating a ground feature heatmap based on the original remote sensing image, wherein the ground feature heatmap represents the computational load distribution of different regions of the original remote sensing image; dividing the original remote sensing image into multiple sub-task blocks based on the ground feature heatmap, thereby balancing the computational load of each sub-task block; performing parallel interpretation and inference on each sub-task block to obtain the inference result of each sub-task block, wherein the inference result carries global location information in the original remote sensing image; identifying multiple inference results corresponding to the same target within the overlapping area of ​​adjacent sub-task blocks based on the global location information of the inference results in the original remote sensing image; and generating an interpretation result covering the original remote sensing image based on the multiple inference results.

Description

Technical Field

[0001] This invention relates to the field of remote sensing technology, and more specifically to a method, apparatus, and electronic device for intelligent interpretation of remote sensing images based on Kubernetes. Background Technology

[0002] With the rapid development of Earth observation technology, high-resolution remote sensing satellites generate massive amounts of image data every day. Deep learning-based intelligent interpretation technologies for remote sensing images, such as target detection, land cover classification, and change detection, have significant application value in fields such as urban planning, agricultural monitoring, and disaster assessment.

[0003] Currently, intelligent interpretation of remote sensing images mainly relies on deep learning models, including the YOLO series, Faster R-CNN, and U-Net. However, when faced with high-resolution remote sensing images at the TB or even PB level, single graphics processor nodes have significant bottlenecks in terms of computing power, memory capacity, and processing efficiency, making it difficult to meet the timeliness requirements of large-scale engineering applications.

[0004] To address the aforementioned issues, the industry generally employs distributed computing technology to coordinate the parallel processing of multiple graphics processing units (GPUs). Existing technologies primarily fall into two categories:

[0005] The first type of approach is based on traditional high-performance computing scheduling systems, with Slurm as a representative. This approach pre-segments the entire remote sensing image into multiple geographic tiles, and the scheduler assigns each tile as an independent job to different graphics processing unit nodes for inference. Finally, the results are merged using an external script. This approach has the following shortcomings: poor integration with containerized runtime environments and a lack of elastic scalability; separation of task splitting and resource scheduling logic, making it difficult to achieve end-to-end automated pipeline management.

[0006] The second approach is based on container orchestration platforms, with Kubernetes as a representative. This approach relies on the device plugin mechanism of the container orchestration platform to support the use of graphics processing unit (GPU) resources within containers. Users need to manually split the large graph into multiple chunks and create container groups for each chunk. The default scheduler then binds the container groups to available GPU nodes. This approach has the following shortcomings: it lacks awareness of the semantics of "a parent task consists of multiple child tasks"; task splitting relies on manual operation and cannot handle dependencies between child tasks; it is difficult to effectively address the single GPU memory bottleneck; and it ignores the boundary effects when merging child tasks, leading to decreased merging accuracy.

[0007] It is evident that existing technologies suffer from low automation levels, insufficient resource utilization, and accuracy loss due to boundary effects when processing massive amounts of remote sensing imagery for intelligent interpretation. Therefore, providing an intelligent scheduling method that is deeply integrated with container orchestration platforms and possesses task-aware capabilities to achieve automatic task decomposition, refined resource scheduling, and end-to-end automated process management has become a pressing technical challenge in this field. Summary of the Invention

[0008] In view of the above problems, the present invention provides a method, apparatus and electronic device for intelligent interpretation of remote sensing images based on Kubernetes, which solves at least one of the above problems.

[0009] According to a first aspect of the present invention, a Kubernetes-based intelligent interpretation method for remote sensing images is provided. The method includes: generating a ground feature heatmap based on an original remote sensing image, the ground feature heatmap representing the computational load distribution of different regions of the original remote sensing image; dividing the original remote sensing image into multiple sub-task blocks based on the ground feature heatmap, such that the computational load of each sub-task block is balanced; performing parallel interpretation inference on each sub-task block to obtain an inference result for each sub-task block, the inference result carrying global location information in the original remote sensing image; identifying multiple inference results corresponding to the same target within overlapping areas of adjacent sub-task blocks based on the global location information of the inference results in the original remote sensing image; and generating an interpretation result covering the original remote sensing image based on the multiple inference results.

[0010] Optionally, generating a ground feature heatmap based on the original remote sensing imagery includes:

[0011] Obtain the edge feature density of densely populated areas of man-made features in the original remote sensing image;

[0012] Obtain the vegetation index of the areas in the original remote sensing image where land features need to be finely identified;

[0013] The relative computational load of each pixel position in the original remote sensing image is calculated based on a weighted combination of the edge feature density and the vegetation index.

[0014] The relative calculated load is added to the basic load constant to obtain the ground feature heat map.

[0015] Optionally, the step of dividing the original remote sensing image into multiple sub-task blocks based on the ground feature heatmap, so that the computational load of each sub-task block is balanced, includes:

[0016] The original remote sensing image is iteratively segmented;

[0017] In each iteration, the total heatmap value of the current block is calculated;

[0018] When the total heatmap value exceeds a preset threshold, the current block will be further divided;

[0019] The segmentation is terminated when the total heatmap value of all sub-blocks is lower than the preset threshold.

[0020] Optionally, the parallel interpretation and reasoning of each of the sub-task blocks to obtain the reasoning result of each sub-task block includes:

[0021] Publish the metadata descriptors of each of the subtask blocks to the message queue;

[0022] The metadata descriptor is obtained from the message queue through the task consumer program;

[0023] Create a container group for each of the aforementioned metadata descriptors;

[0024] The container group is scheduled to an available graphics processor node, which is a compute node in a Kubernetes cluster;

[0025] The inference operation of the preset deep learning model is executed on the graphics processor node.

[0026] Optionally, scheduling the container group to an available graphics processor node includes:

[0027] Obtain the hardware topology information of each graphics processor node in the cluster;

[0028] Calculate a comprehensive score for each graphics processor node, which is positively correlated with the interconnect bandwidth between graphics processors within the node and negatively correlated with the number of network hops across nodes;

[0029] The graphics processor node with the highest overall score is selected as the scheduling target for the container group.

[0030] Optionally, based on the global location information of the inference results in the original remote sensing image, multiple inference results corresponding to the same target within the overlapping area of ​​adjacent sub-task blocks are identified, including:

[0031] Perform geographic coordinate remapping correction on each of the inference results to obtain the corrected target location;

[0032] Based on the corrected target location, identify multiple corrected inference results corresponding to the same target within the overlapping area of ​​adjacent subtask blocks.

[0033] Optionally, generating interpretation results covering the original remote sensing image based on the multiple inference results includes:

[0034] Obtain the confidence score for each of the corrected inference results;

[0035] Based on the confidence scores, the multiple corrected inference results are weighted and fused.

[0036] The fused single result is used as the final detection result within the overlapping region;

[0037] Based on the final detection results, an interpretation result covering the original remote sensing image is generated.

[0038] Optionally, the calculation formula for the weighted fusion is:

[0039]

[0040] in, This represents the pixel value at position (x, y) after fusion. This represents the confidence level of the i-th corrected inference result. Let represent the detection value of the i-th corrected inference result at position (x, y). This represents the geographic coordinate remapping mask value of the i-th corrected inference result.

[0041] According to a second aspect of the present invention, a Kubernetes-based intelligent interpretation device for remote sensing images is provided. The device includes: a heatmap generation module for generating a ground feature heatmap based on an original remote sensing image, the ground feature heatmap representing the computational load distribution of different regions of the original remote sensing image; a task segmentation module for segmenting the original remote sensing image into multiple sub-task blocks based on the ground feature heatmap, such that the computational load of each sub-task block is balanced; a parallel inference module for performing parallel interpretation inference on each sub-task block to obtain inference results for each sub-task block, the inference results carrying global location information in the original remote sensing image; a result recognition module for identifying multiple inference results corresponding to the same target within overlapping areas of adjacent sub-task blocks based on the global location information of the inference results in the original remote sensing image; and a result generation module for generating interpretation results covering the original remote sensing image based on the multiple inference results.

[0042] According to a third aspect of the present invention, an electronic device is provided, comprising: at least one processor; at least one memory storing computer program instructions; wherein, when the computer program instructions are executed by the at least one processor, the electronic device performs the method described in any one of the first aspects.

[0043] According to the embodiments of this application, end-to-end processing from image input to interpretation result output can be completed automatically without manual intervention, significantly improving processing efficiency; by using a block strategy for load balancing, the problem of some graphics processors being overloaded while others are idle, which is caused by traditional uniform block partitioning, is avoided, effectively improving the resource utilization of multi-graphics processor clusters; by identifying and merging multiple inference results of the same target in overlapping areas, the problems of duplicate detection and boundary seams caused by block processing are eliminated, ensuring the integrity and accuracy of the final interpretation result. Attached Figure Description

[0044] The above-described features, other objects, and advantages of the present invention will become clearer from the following description of embodiments of the invention with reference to the accompanying drawings, in which:

[0045] Figure 1 A flowchart illustrating a Kubernetes-based intelligent interpretation method for remote sensing images according to an embodiment of the present invention is shown.

[0046] Figure 2 This illustration schematically shows a multi-level, multi-GPU scheduling flowchart for intelligent interpretation of remote sensing images based on Kubernetes, according to an embodiment of the present invention.

[0047] Figure 3 This schematic diagram illustrates the structural block diagram of a Kubernetes-based intelligent interpretation method apparatus for remote sensing images according to an embodiment of the present invention.

[0048] Figure 4 A block diagram of an electronic device suitable for implementing a Kubernetes-based intelligent interpretation method for remote sensing images is illustrated according to an embodiment of the present invention. Detailed Implementation

[0049] Hereinafter, embodiments of the present invention will be described with reference to the accompanying drawings. However, it should be understood that these descriptions are exemplary only and are not intended to limit the scope of the invention. In the following detailed description, numerous specific details are set forth to provide a thorough understanding of the embodiments of the invention for ease of explanation. However, it will be apparent that one or more embodiments may be practiced without these specific details. Furthermore, descriptions of well-known structures and techniques are omitted in the following description to avoid unnecessarily obscuring the concept of the invention.

[0050] The terminology used herein is for the purpose of describing particular embodiments only and is not intended to limit the invention. The terms “comprising,” “including,” etc., as used herein indicate the presence of the stated features, steps, operations, and / or components, but do not exclude the presence or addition of one or more other features, steps, operations, or components.

[0051] All terms used herein (including technical and scientific terms) have the meanings commonly understood by those skilled in the art, unless otherwise defined. It should be noted that the terms used herein are to be interpreted in a manner consistent with the context of this specification, and not in an idealized or overly rigid way.

[0052] When using expressions such as "at least one of A, B and C", they should generally be interpreted in accordance with the meaning that is commonly understood by those skilled in the art (e.g., "a system having at least one of A, B and C" should include, but is not limited to, a system having A alone, a system having B alone, a system having C alone, a system having A and B, a system having A and C, a system having B and C, and / or a system having A, B and C, etc.).

[0053] In this embodiment of the invention, "Kubernetes" is an open-source container orchestration platform used for the automated deployment, scaling, and management of containerized applications. This platform organizes containers running applications into logical units (called container groups) and provides functions such as service discovery and load balancing, storage orchestration, automated deployment and rollback, automated scaling, and self-healing.

[0054] In this embodiment of the invention, Kubernetes serves as the underlying resource management platform, responsible for managing the resources of graphics processor nodes in the cluster, scheduling the creation, execution, and destruction of container groups, and providing a declarative application deployment interface. Through Kubernetes' application programming interface, users can dynamically create container groups, specify resource requirements (such as the number of graphics processors and memory size), monitor task status, and collect execution logs, thereby achieving automated orchestration and scheduling of large-scale parallel inference tasks.

[0055] Figure 1 A flowchart illustrating a Kubernetes-based intelligent interpretation method for remote sensing images according to an embodiment of the present invention is shown.

[0056] like Figure 1 As shown, the Kubernetes-based intelligent interpretation method for remote sensing images in this embodiment includes operations S110 to S150.

[0057] In operation S110, a ground feature heat map is generated based on the original remote sensing image. The ground feature heat map represents the distribution of computational load in different areas of the original remote sensing image.

[0058] According to embodiments of the present invention, raw remote sensing imagery refers to surface imagery data acquired by sensors mounted on satellites, drones, or aircraft. This imagery data may include multispectral bands, panchromatic bands, or synthetic aperture radar data. For example, raw remote sensing imagery may be a four-band multispectral imagery taken by the Gaofen-1 satellite, including red, green, blue, and near-infrared bands.

[0059] According to an embodiment of the present invention, the ground feature heatmap is a two-dimensional matrix with the same spatial dimension as the original remote sensing image. Each element value in the matrix represents the relative computational load required to process the corresponding pixel location. The specific value of the relative computational load can be determined by analyzing the complexity of the ground feature types in the image. For example, densely built-up areas, road network areas, or areas containing a large amount of edge information have a higher computational load because the deep learning model needs to process more features; while areas with simple textures, such as water surfaces, deserts, and bare land, have a lower computational load.

[0060] For example, for a 10,000×10,000 pixel remote sensing image, the generated land feature heatmap is also a 10,000×10,000 matrix, where the pixel heat value for urban areas is 0.9, the pixel heat value for farmland areas is 0.5, and the pixel heat value for water areas is 0.2. These values ​​are used for subsequent patching decisions.

[0061] When operating S120, the original remote sensing image is divided into multiple sub-task blocks based on the ground feature heat map, so that the computational load of each sub-task block is balanced.

[0062] According to embodiments of the present invention, the goal of segmentation is to control the difference in the total heatmap value of the area covered by each subtask block within a preset range, thereby achieving a balanced distribution of computational load. The segmented subtask blocks can differ in spatial size: areas with high computational load (such as urban areas) are segmented into smaller blocks, while areas with low computational load (such as water areas) are segmented into larger blocks.

[0063] For example, a remote sensing image containing cities, farmland, and water areas can be segmented based on the land cover heatmap as follows: the urban area is divided into multiple 512×512 pixel sub-blocks, the farmland area into multiple 1024×1024 pixel sub-blocks, and the water area into multiple 2048×2048 pixel sub-blocks. Although the spatial dimensions of each sub-block are different, the total heatmap value within each sub-block is basically the same, for example, all controlled within the range of 10000±500.

[0064] According to embodiments of the present invention, to ensure seamless splicing of inference results from adjacent subtask blocks, overlapping regions can be set during segmentation. For example, an 8-pixel-wide overlap band can be set between two adjacent subtask blocks to prevent targets located on block boundaries from being cut off.

[0065] In operation S130, parallel interpretation and inference are performed on each sub-task block to obtain the inference results of each sub-task block, which contain global location information in the original remote sensing image.

[0066] According to embodiments of the present invention, parallel interpretation inference refers to simultaneously allocating multiple subtask blocks to multiple graphics processors to perform inference computations on deep learning models. Each subtask block is processed independently without interference.

[0067] According to embodiments of the present invention, the inference result refers to the detection information output by the deep learning model after interpreting the subtask block. Depending on the interpretation task, the inference result may include the following types: for object detection tasks, the inference result includes the coordinates of the object bounding box, the object category, and the confidence score; for land cover classification tasks, the inference result includes the category label of each pixel; for change detection tasks, the inference result includes the location and type of the changed area.

[0068] According to embodiments of the present invention, global location information refers to the actual geographic coordinates or pixel coordinates of the target in the original remote sensing image in the inference result. For example, if a sub-task block corresponds to an area in the original image with upper left corner coordinates of (1000, 1000) and lower right corner coordinates of (2000, 2000), then the global coordinates of the target detected in the sub-task block need to be increased by the offset of the block. Specifically, if the local coordinates of a target in the sub-task block are (50, 80), then the global coordinates of the target in the original remote sensing image are (1050, 1080).

[0069] In operation S140, based on the global location information of the inference results in the original remote sensing image, multiple inference results corresponding to the same target are identified within the overlapping area of ​​adjacent sub-task blocks.

[0070] According to an embodiment of the present invention, since an overlapping region is set in operation S120, the same target located within the overlapping region may be detected simultaneously by two or more adjacent subtask blocks, thereby generating multiple inference results. The purpose of the identification operation is to group these multiple inference results belonging to the same target into one group, in preparation for subsequent fusion processing.

[0071] Specific identification methods can be based on the intersection-union ratio (IU) of the target bounding boxes. For example, an IU threshold of 0.5 can be set. When the IU of two target bounding boxes is greater than 0.5, the two detection results are determined to correspond to the same target. The width of the overlapping region can be set according to actual needs, such as half the maximum size of the target, or a fixed pixel value such as 64 pixels or 128 pixels.

[0072] For example, a car is located in the overlapping area of ​​adjacent blocks A and B. The inference result of block A contains the detection box of the car, and the inference result of block B also contains the detection box of the car. By calculating the intersection-union ratio (IUR) of the two detection boxes, if the IUR value is 0.7, which is greater than the preset threshold of 0.5, then the two inference results are identified as corresponding to the same car.

[0073] In operation S150, interpretation results covering the original remote sensing image are generated based on multiple inference results.

[0074] According to an embodiment of the present invention, generating an interpretation result refers to processing multiple inference results identified as belonging to the same target and outputting a complete and unique interpretation result. The size of this interpretation result is the same as that of the original remote sensing image, covering the entire image area.

[0075] For multiple inference results corresponding to the same target within overlapping regions, various methods can be used to merge them into a single result. For example, the inference result with the highest confidence can be selected as the final result, while other results can be discarded. Alternatively, the geometric mean of the bounding boxes of multiple inference results can be calculated as the final bounding box. For inference results in non-overlapping regions, their original detection information is directly retained.

[0076] The final interpretation results can be output in different formats depending on the task type. For example, for object detection tasks, the output can be a GeoJSON file, which contains the category, confidence score, and geographic coordinates of each detected object. For land cover classification tasks, the output can be a GeoTIFF raster image, where each pixel value represents the land cover category code at that location.

[0077] According to embodiments of the present invention, end-to-end processing from image input to interpretation result output can be completed automatically without manual intervention, significantly improving processing efficiency. By employing a load-balanced block strategy, the problem of some graphics processors being overloaded while others are idle, which is common with traditional uniform block processing, is avoided, effectively improving the resource utilization of multi-graphics processor clusters. By identifying and merging multiple inference results for the same target within overlapping areas, the problems of duplicate detection and boundary seams caused by block processing are eliminated, ensuring the integrity and accuracy of the final interpretation result.

[0078] Figure 2 The diagram illustrates a multi-level, multi-GPU scheduling flowchart for intelligent interpretation of remote sensing images based on Kubernetes, according to an embodiment of the present invention.

[0079] like Figure 2 As shown, the Kubernetes-based multi-level multi-GPU scheduling method for intelligent interpretation of remote sensing images in this embodiment includes the following three stages: intelligent task splitting, multi-level task scheduling and inference, and dynamic result stitching.

[0080] like Figure 2 As shown in the intelligent task breakdown stage, after inputting the global remote sensing image, the system first obtains basic information such as the image's width, height, and number of channels, and then preprocesses the image.

[0081] According to embodiments of the present invention, the generation of a ground feature heatmap requires comprehensive consideration of the impact of different ground feature types on the computational load. Embodiments of the present invention construct ground feature heatmaps using the following method.

[0082] First, the edge feature density of densely populated areas of man-made features in the original remote sensing image is obtained. These areas include building complexes, road networks, parking lots, etc. Because they contain a large amount of geometric edge and texture information, deep learning models require more computational resources to process them. Edge feature density can be extracted using edge detection algorithms.

[0083] For example, the Canny edge detection operator is used to extract edge pixels in an image, and then Gaussian blurring is applied to the edge image so that the edge density value of each pixel reflects the edge intensity in its neighborhood. Specifically, for a 10000×10000 pixel image, a binary edge map is obtained after detection by the Canny operator, and then convolution is performed using a Gaussian kernel with σ=5 to obtain edge density values ​​that are continuously distributed between 0 and 1.

[0084] Secondly, vegetation indices need to be obtained from the original remote sensing imagery for areas requiring detailed identification of ground features. These areas include farmland (requiring identification of crop type and growth status) and forests (requiring identification of tree species and canopy density). The vegetation index can be obtained using the Normalized Difference Vegetation Index (NDI), which is calculated using the red and near-infrared bands of the remote sensing imagery. The formula is (NIR - Red) / (NIR + Red), where NIR is the reflectance value in the near-infrared band and Red is the reflectance value in the red band. The NDI ranges from -1 to 1, with higher values ​​(closer to 1) for lush vegetation areas and lower values ​​(closer to 0 or negative) for areas without vegetation. For example, the NDI for dense forest areas is approximately 0.8, for farmland approximately 0.6, for urban bare soil areas approximately 0.2, and for water bodies approximately -0.1.

[0085] Next, based on a weighted combination of edge feature density and vegetation index, the relative computational load of each pixel location in the original remote sensing image is calculated. For example... Figure 2 As shown, this step generates the calculated load heatmap H(x,y). The formula for calculating the weighted combination is as follows:

[0086]

[0087] Where H(x,y) represents the heatmap value at position (x,y); Indicates the position of the i-th type of edge feature. The density value at the location; wi is the weight coefficient corresponding to the i-th type of edge feature; α is the weight coefficient of the vegetation index; γ represents the normalized vegetation index at location (x,y); γ is the basic load constant.

[0088] Various weighting coefficients can be optimized by fitting historical task data. For example, for urban building detection tasks, since building edges have a significant impact on computational load, the weight of building edges can be set to 0.5, road edges to 0.2, vehicle edges to 0.1, and vegetation index to 0.2. For land cover classification tasks, since fine differentiation of vegetation types is required, the weight of vegetation index can be set to 0.5, with the total weight of all edge features at 0.5. Specifically, a linear regression method can be used, with the actual subtask inference time as the target variable and various edge densities and vegetation indices as feature variables, to train and obtain the optimal weighting coefficients.

[0089] Finally, the relative computational load is added to the base load constant to obtain the ground feature heatmap. The base load constant γ represents the basic computational load required to run the deep learning model, even in areas with uniform texture and no significant features (such as water surfaces, deserts, and bare land). For example, the base load constant can be set to 0.1.

[0090] like Figure 2 As shown, based on the ground feature heat map, the embodiments of the present invention can adopt an iterative segmentation method to dynamically divide the original remote sensing image into several computationally balanced sub-task blocks guided by the ground feature heat map.

[0091] Before starting iterative segmentation, a reference value for the initial block size can be calculated based on the number of available graphics processors in the cluster and the total number of pixels in the original image. The specific calculation formula is as follows:

[0092]

[0093] in, This indicates the maximum number of pixels a single graphics processor can process (e.g., 4096 × 4096 = 16,777,216 pixels). TotalPixels represents the total number of pixels in the original remote sensing image. This indicates the number of available graphics processors in the cluster, and β is the load balancing factor (default value is 1.2). This reference value serves as the upper limit for the initial block size of iterative partitioning.

[0094] Specifically, the original remote sensing image is iteratively segmented, with each segmentation performing a judgment on the current block. In each iteration, the total heatmap value of the current block is calculated, which is the sum of the heatmap values ​​of all pixels within the block. When the total heatmap value exceeds a preset threshold, the current block is further segmented into smaller sub-blocks. The segmentation method can be to divide the current block into two equal halves horizontally or vertically, or to use a quadtree segmentation method to divide the current block into four equal sub-blocks. After segmentation, the above judgment process is repeated for each newly generated sub-block. The segmentation terminates when the total heatmap value of all sub-blocks is lower than or equal to the preset threshold.

[0095] The preset threshold can be set based on the processing power and video memory capacity of the graphics processors in the cluster. For example, if the maximum total heatmap value that a single graphics processor can efficiently process is 5000, then the preset threshold can be set to 5000. For an image with a total heatmap value of 100,000, after the above iterative segmentation, approximately 20 sub-task blocks will be generated, with each block having a total heatmap value around 5000.

[0096] It should be noted that because the total heatmap values ​​of each block are matched rather than their spatial dimensions, the resulting sub-task blocks can differ in spatial size. For example, sub-task blocks in urban areas may have smaller spatial dimensions (e.g., 256×256 pixels), but their total heatmap values ​​are close to a preset threshold; sub-task blocks in water areas may have larger spatial dimensions (e.g., 4096×4096 pixels), and their total heatmap values ​​are also close to the preset threshold. This computationally-based partitioning method is fundamentally different from traditional uniform partitioning based on fixed sizes.

[0097] Furthermore, to facilitate subsequent result stitching, overlapping areas can be set between adjacent sub-task blocks during segmentation. For example, during each segmentation, the boundaries of each sub-block can be extended outward by a certain number of pixels (e.g., 64 pixels), resulting in overlapping bands between adjacent blocks.

[0098] like Figure 2 As shown, after the segmentation is completed, subtask metadata and a task list are generated, and the task descriptors are placed into the task queue.

[0099] like Figure 2 As shown in the multi-level scheduling and inference stage of the task, in order to achieve efficient parallel processing of large-scale subtask blocks, a producer-consumer pattern based on message queues can be adopted.

[0100] Specifically, the metadata descriptors for each subtask block are first published to a message queue. A metadata descriptor is a data structure that describes the attributes of a subtask block, including at least the following information: a unique identifier for the subtask block (e.g., task ID), the subtask block's location information in the original image (e.g., top-left pixel coordinates, width, and height), the storage path of the subtask block (e.g., the file path of the original image sub-map), and the estimated computational load. The message queue can use a Redis list data structure, RabbitMQ's message broker service, or Kafka's distributed messaging system. For example, in Redis, the LPUSH command is used to push all task descriptors into a queue named "task_queue".

[0101] Secondly, a task consumer program retrieves metadata descriptors from the message queue. The task consumer program is a persistent daemon process that can be deployed using Kubernetes Deployment resources, with multiple replicas configured for high-throughput consumption. This consumer program continuously polls the message queue, and when there are tasks awaiting processing, it uses the RPOP command to pop a task descriptor from the queue.

[0102] Then, a container group (i.e.,) is created for each metadata descriptor. Figure 2 (The inference pod). A container group is the basic unit for deploying and running containers in Kubernetes. A container group can contain one or more containers. For each acquired task, the consumer program calls the Kubernetes application programming interface to dynamically create a container group containing the inference task container. The inference task container comes pre-loaded with a deep learning inference engine and model files.

[0103] Next, the container group will be scheduled to an available graphics processor node. Figure 2 In a Kubernetes cluster, each node can be configured with one or more graphics processors (GPUs). An available GPU node is a compute node in the cluster that is in good working order, has sufficient resources, and has idle GPU resources. For example, in a cluster with 8 GPU servers, each equipped with 4 NVIDIA Tesla V100 GPUs, the scheduler selects the GPUs with the lowest current load from these 32 GPUs for allocation.

[0104] Finally, inference operations of a pre-defined deep learning model are executed on the graphics processing unit (GPU) node. The pre-defined deep learning model is determined based on the specific interpretation task: for object detection, the YOLOv8 model can be used; for land cover classification, the U-Net model can be used; and for change detection, the SiamFC model can be used. After the inference operation is completed, the container group writes the inference results to shared storage and automatically destroys itself to release resources.

[0105] In some embodiments, such as Figure 2 As shown, in the Volcano batch scheduling step, during the process of scheduling multiple container groups to the graphics processor node, this embodiment of the invention employs a batch scheduling strategy to optimize resource utilization efficiency. Specifically, it includes the following three core strategies:

[0106] First, the group scheduling strategy. When multiple sub-task blocks have dependencies (e.g., adjacent blocks need to share edge information), the scheduler groups these related sub-tasks together, ensuring that all tasks within the group obtain resources simultaneously and begin execution. This avoids deadlocks caused by insufficient resources for some tasks and also prevents resource waste caused by scheduled tasks waiting for unscheduled tasks.

[0107] Second, resource packaging strategy. The scheduler prioritizes scheduling multiple container groups compactly onto the same node or as few nodes as possible, improving the resource utilization density of a single node. For example, if a node has 4 graphics processors, the scheduler will prioritize scheduling all 4 container groups onto that node, rather than distributing them across 4 different nodes. This reduces the number of active nodes in the cluster, lowering energy consumption and computing costs.

[0108] Third, the queuing mechanism. The scheduler sets up independent resource queues for tasks of different priorities or from different users, with each queue enjoying a configured resource quota. For example, high-priority real-time interpretation tasks can be assigned to the guaranteed resource queue to ensure rapid response; low-priority batch processing tasks use the elastic resource queue to execute when the cluster is idle. This achieves fair allocation and isolation of resources.

[0109] In some embodiments, after a subtask block completes its inference operation, the inference result (along with its global coordinates in the original image) is written to a designated location in shared storage in a standard format (e.g., GeoJSON). Shared storage can employ various distributed storage systems, such as MinIO object storage, HDFS distributed file system, Ceph distributed storage, etc.

[0110] like Figure 2As shown, in topology-aware allocation, in order to optimize the communication efficiency across GPUs and reduce the latency overhead of distributed inference, a hardware topology-aware scheduler can be introduced to schedule container groups to available GPU nodes.

[0111] Specifically, the first step is to obtain the hardware topology information of each graphics processor node in the cluster. This hardware topology information includes: whether a high-speed interconnect bus (such as NVLink or MLink) exists between the graphics processors within a node, the bandwidth parameters of the high-speed interconnect bus, the network connection topology between nodes, and the network hop count between nodes. For example, within the same physical server, four graphics processors may be fully interconnected via NVLink, with a communication bandwidth of up to 600GB / s; while communication between graphics processors on different servers requires network switching equipment, with a communication bandwidth typically of 25Gb / s and a network hop count of 2.

[0112] Next, a comprehensive score is calculated for each graphics processing unit (GPU) node. This score is designed to be positively correlated with the interconnect bandwidth between GPUs within the node and negatively correlated with the number of network hops across nodes. Nodes with higher scores are prioritized when there are dependencies between multiple subtask blocks or when frequent communication is required. For example, a weighted scoring function can be used:

[0113]

[0114] in, This indicates the actual bandwidth of the high-speed interconnect bus between graphics processors within the node. This represents a reference bandwidth (e.g., 200GB / s), and the ratio of this to the reference bandwidth measures the relative performance of the interconnect bandwidth between graphics processors within a node. A higher bandwidth ratio results in a higher score for this item, with a maximum weight of 0.7. NetworkHop represents the number of network hops for cross-node communication. This is the attenuation coefficient (default value is 2.0). This is an exponentially decaying term; the fewer the number of network hops, the higher the score for this term, with a maximum weight of 0.3. For example, the exponential term is approximately 0.6065 when the number of network hops is 1, approximately 0.3679 when the number of network hops is 2, and approximately 0.2231 when the number of network hops is 3.

[0115] Finally, the graphics processor node with the highest overall score is selected as the scheduling target for the container group.

[0116] For example, suppose node A's graphics processors are interconnected via NVLink with a bandwidth ratio of 1.0, resulting in a score of 0.7. Its network hop count with shared storage is 1, with an exponent of 0.6065, giving it a score of 0.3 × 0.6065 = 0.1820, for a total score of 0.8820. Node B's graphics processors are interconnected via PCIe with a bandwidth ratio of 0.3, resulting in a score of 0.21. Its network hop count is 3, with an exponent of 0.2231, giving it a score of 0.3 × 0.2231 = 0.0669, for a total score of 0.2769. The scheduler will prioritize node A, with its higher total score, to execute tasks requiring high communication bandwidth.

[0117] like Figure 2 As shown, in the node affinity constraint step, in addition to topology-aware scheduling based on comprehensive scores, embodiments of the present invention can also employ a node affinity constraint strategy. This strategy ensures that subtask blocks requiring close collaboration (e.g., blocks from adjacent regions in the original image) are intelligently placed on physically adjacent graphics processor nodes. Specifically, when creating container groups, by setting node affinity rules, the scheduler is required to prioritize scheduling subtask blocks with adjacent spatial relationships to nodes on the same node or within the same rack. This reduces cross-node data transmission latency and provides performance guarantees for communication-intensive intelligent interpretation tasks.

[0118] like Figure 2 As shown in the sub-result reading phase, the inference results of all subtask blocks are first collected. Each inference result contains at least the global coordinates of the target bounding box, the target category, and the confidence score. It should be noted that setting overlapping regions in the intelligent task splitting phase is to prevent meaningful targets located at the edges of subtask blocks (especially edge targets) from being cut off, thus leading to missed detections.

[0119] Because overlapping regions are set during the task segmentation phase, the same target located within an overlapping region may be detected simultaneously by multiple adjacent sub-task blocks. Embodiments of the present invention can first perform corrections on these inference results before identification.

[0120] like Figure 2As shown in the geo-coordinate remapping stage and the elimination of stitching gaps, geo-coordinate remapping correction is first performed on each inference result to obtain the corrected target location. Geo-coordinate remapping correction aims to eliminate geometric distortions caused by remote sensing image projection transformations and sensor attitude changes. Original remote sensing images typically contain geo-projection information, such as the Universal Transverse Mercator projection coordinate system. Due to projection transformations, the actual ground distances corresponding to pixels at different locations in the image are not the same (e.g., pixel resolution differs between high-latitude and equatorial regions). The correction process uses a geo-coordinate remapping mask, which is pre-calculated based on the projection information of the remote sensing image. For the four vertex coordinates of each detection box in the inference result, the remapping mask is used to map them to the corrected coordinate positions. For example, a pixel at position (1000, 1000) in the original image may correspond to position (998, 1003) after projection correction.

[0121] For example, geographic coordinate remapping correction is achieved using a pre-generated remapping mask. This mask is pre-calculated based on the projection information of the original remote sensing image (such as the universal transverse Mercator projection parameters). The correction process can be expressed by the following formula:

[0122] (xfinal,yfinal)=Mgeo(xglobal,yglobal)

[0123] Where (xglobal, yglobal) represents the global coordinates of the detection box in the original image coordinate system in the inference result, Mgeo(⋅) is the remapping function constructed based on the projection information, and (xfinal, yfinal) is the corrected target position. This correction eliminates geometric distortions caused by projection transformations (such as pixel stretching in high-latitude regions) and sensor pose changes, fundamentally eliminating gaps and positioning errors in the subsequent stitching process.

[0124] Secondly, based on the corrected target location, multiple corrected inference results corresponding to the same target within the overlapping area of ​​adjacent subtask blocks are identified. The identification method can be based on the bounding box intersection-union ratio (IUU). Specifically, for any two detection boxes located within the overlapping area, the ratio of their intersection area to their union area is calculated. When this ratio exceeds a preset threshold (e.g., 0.5), the two detection boxes are determined to correspond to the same target. The range of the overlapping area can be determined based on the overlap band width set during the original segmentation. For example, if the overlap band width is 64 pixels, cross-block matching is only performed on detection boxes located within a 32-pixel range outside the boundary of each block.

[0125] like Figure 2 As shown, in the confidence-weighted fusion step, after identifying multiple corrected inference results corresponding to the same target, the embodiments of the present invention can use the confidence-weighted fusion method to generate the final detection result.

[0126] Specifically, the confidence score for each corrected inference result is first obtained. The confidence score is the probability value that the deep learning model attaches to the output detection result, representing the model's degree of certainty regarding that detection result. For example, when the YOLOv8 model outputs the category "car" for a detection box, it will also output a confidence score between 0 and 1. A score of 0.92 indicates that the model is 92% confident that the target is a car. The higher the confidence score, the more reliable the detection result.

[0127] Secondly, based on the confidence scores, multiple corrected inference results are weighted and fused. The purpose of weighted fusion is to combine multiple detection results into a more accurate result. For example, for the same car, the detection result of block A is bounding box (x1, y1, x2, y2) with a confidence score of 0.9; the detection result of block B is bounding box (x1', y1', x2', y2') with a confidence score of 0.7. The coordinates of the weighted and fused bounding box can be calculated by the weighted average of the confidence scores of each bounding box coordinate: the top-left x-coordinate of the fused bounding box = (0.9 × x1 + 0.7 × x1') / (0.9 + 0.7), and other coordinates are calculated similarly.

[0128] Then, the fused single result is used as the final detection result within the overlapping region. This fused result has higher robustness and accuracy than the detection result of any single subtask block.

[0129] like Figure 2 As shown, the final interpretation result map is generated. Based on the final detection results, interpretation results covering the original remote sensing image are generated. The interpretation results can store the bounding boxes, categories, and confidence scores of the detected targets in vector formats (such as GeoJSON or Shapefile), or output pixel-level classification labels in raster formats (such as GeoTIFF). The final interpretation results have the same spatial extent and georeferenced information as the original remote sensing image and can be directly used for downstream geographic information system analysis.

[0130] This invention provides a specific weighted fusion calculation formula:

[0131]

[0132] in, This represents the pixel value at position (x, y) after fusion. This value can be the probability of the detection box in an object detection task, or the category probability distribution in a land cover classification task.

[0133] This represents the confidence level of the i-th corrected inference result, ranging from 0 to 1. This value is output by the deep learning model during the inference process, such as the target confidence level output by the YOLOv8 model.

[0134] This represents the detection value of the i-th corrected inference result at position (x, y). For object detection tasks, this value represents the probability that the position belongs to a certain bounding box; for land cover classification tasks, this value represents the probability that the pixel belongs to a certain land cover category.

[0135] This represents the geographic coordinate remapping mask value of the i-th corrected inference result. This mask is a weight matrix pre-calculated based on the projection information of the remote sensing image, with values ​​ranging from 0 to 1. Within the overlapping region, pixels closer to the center of the sub-task block have higher mask values, while pixels closer to the block boundary have lower mask values. This design can reduce the negative impact of errors caused by geometric distortion at the boundary on the fusion result.

[0136] n represents the number of sub-task blocks that produce detection results for the same target, i.e., the number of sub-task blocks covered by the overlapping area.

[0137] The physical meaning of this calculation formula is as follows: For each pixel location within the overlapping region, a weighted average is calculated for the detection results of all sub-task blocks covering that location. The weight is the product of the confidence score and the geographic mask value of each sub-task block. Detection results with higher confidence scores and closer to the block center receive greater weight in the fusion process. Compared to traditional non-maximum suppression methods, this formula can retain and fuse information from multiple detection results, rather than simply discarding low-confidence results, thus obtaining a more accurate and robust final detection result.

[0138] For example, suppose a pixel location within the overlapping region of two subtask blocks has a detection value of 0.9 (confidence 0.8, mask value 0.9) in block A and a detection value of 0.7 (confidence 0.6, mask value 1.0) in block B. Then the fused pixel value would be:

[0139]

[0140] The merged detection value is approximately 0.809, which is between the two original detection values ​​but closer to the detection value of block A, which has a higher confidence level.

[0141] Figure 3 This schematic diagram illustrates the structural block diagram of a Kubernetes-based intelligent interpretation method apparatus for remote sensing images according to an embodiment of the present invention.

[0142] like Figure 3As shown, the remote sensing image intelligent interpretation device based on the container orchestration platform in this embodiment includes a heat map generation module 310, a task segmentation module 320, a parallel reasoning module 330, a result recognition module 340, and a result generation module 350.

[0143] The heatmap generation module 310 is used to generate a ground feature heatmap based on the original remote sensing image. The ground feature heatmap represents the computational load distribution of different areas of the original remote sensing image. In one embodiment, the heatmap generation module 310 can be used to perform the operation S110 described above, which will not be repeated here.

[0144] The task segmentation module 320 is used to segment the original remote sensing image into multiple sub-task blocks based on the ground feature heat map, so that the computational load of each sub-task block is balanced. In one embodiment, the task segmentation module 320 can be used to perform the operation S120 described above, which will not be repeated here.

[0145] The parallel inference module 330 is used to perform parallel interpretation and inference on each subtask block to obtain the inference result of each subtask block. The inference result carries global location information in the original remote sensing image. In one embodiment, the parallel inference module 330 can be used to perform the operation S130 described above, which will not be repeated here.

[0146] The result recognition module 340 is used to identify multiple inference results corresponding to the same target within the overlapping area of ​​adjacent subtask blocks based on the global location information of the inference results in the original remote sensing image. In one embodiment, the result recognition module 340 can be used to perform the operation S140 described above, which will not be repeated here.

[0147] The result generation module 350 is used to generate interpretation results covering the original remote sensing image based on multiple inference results. In one embodiment, the result generation module 350 can be used to perform the operation S150 described above, which will not be repeated here.

[0148] According to embodiments of the present invention, any plurality of modules among the heatmap generation module 310, task segmentation module 320, parallel inference module 330, result recognition module 340, and result generation module 350 can be merged into one module, or any one of these modules can be split into multiple modules. Alternatively, at least part of the functionality of one or more of these modules can be combined with at least part of the functionality of other modules and implemented in one module. According to embodiments of the present invention, at least one of the heatmap generation module 310, task segmentation module 320, parallel inference module 330, result recognition module 340, and result generation module 350 can be at least partially implemented as hardware circuitry, such as a field-programmable gate array (FPGA), a programmable logic array (PLA), a system-on-a-chip, a system-on-a-substrate, a system-on-package, an application-specific integrated circuit (ASIC), or any other reasonable means of integrating or packaging circuitry, or implemented in hardware or firmware, or in any one of software, hardware, and firmware implementations, or in a suitable combination of any of these. Alternatively, at least one of the heatmap generation module 310, task segmentation module 320, parallel reasoning module 330, result recognition module 340, and result generation module 350 can be at least partially implemented as a computer program module, which can perform corresponding functions when the computer program module is run.

[0149] Figure 4 A block diagram of an electronic device suitable for implementing a Kubernetes-based intelligent interpretation method for remote sensing images is illustrated according to an embodiment of the present invention.

[0150] like Figure 4 As shown, an electronic device according to an embodiment of the present invention includes a computing unit 401, which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 402 or a program loaded from a storage unit 408 into a random access memory (RAM) 403. The computing unit 401 may include, for example, a general-purpose microprocessor (e.g., a CPU), an instruction set processor and / or an associated chipset and / or a special-purpose microprocessor (e.g., an application-specific integrated circuit (ASIC)), etc. The computing unit 401 may also include onboard memory for caching purposes. The processor 401 may include a single processing unit or multiple processing units for performing different actions of the method flow according to an embodiment of the present invention.

[0151] RAM 403 stores various programs and data required for the operation of electronic device 400. Computing unit 401, ROM 402, and RAM 403 are interconnected via bus 404. Computing unit 401 executes various operations of the method flow according to embodiments of the present invention by executing programs in ROM 402 and / or RAM 403. It should be noted that programs may also be stored in one or more memories other than ROM 402 and RAM 403. Processor 401 may also execute various operations of the method flow according to embodiments of the present invention by executing programs stored in one or more memories.

[0152] According to embodiments of the present invention, the electronic device may further include an input / output (I / O) interface 405, which is also connected to a bus 404. The electronic device 400 may further include one or more of the following components connected to the input / output (I / O) interface 405: an input unit 406 including a keyboard, mouse, etc.; an output unit 407 including a cathode ray tube (CRT), liquid crystal display (LCD), etc., and a speaker, etc.; a storage unit 408 including a hard disk, etc.; and a communication unit 409 including a network interface card such as a LAN card, modem, etc. The communication unit 409 performs communication processing via a network such as the Internet.

[0153] The present invention also provides a computer-readable storage medium, which may be included in the device / apparatus / system described in the above embodiments; or it may exist independently and not assembled into the device / apparatus / system. The computer-readable storage medium carries one or more programs, which, when executed, implement the intelligent interpretation method for remote sensing images based on a container orchestration platform according to embodiments of the present invention.

[0154] According to embodiments of the present invention, a computer-readable storage medium may be a non-volatile computer-readable storage medium, such as including, but not limited to: portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof. In the present invention, a computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. For example, according to embodiments of the present invention, a computer-readable storage medium may include ROM 402 and / or RAM 403 and / or one or more memories other than ROM 402 and RAM 403 described above.

[0155] Embodiments of the present invention also include a computer program product comprising a computer program containing program code for performing the methods shown in the flowchart. When the computer program product is run on a computer system, the program code enables the computer system to implement the intelligent interpretation method for remote sensing images based on a container orchestration platform provided in the embodiments of the present invention.

[0156] When the computer program is executed by the processor 401, it performs the functions defined in the system / apparatus of this embodiment of the invention. According to embodiments of the invention, the systems, apparatuses, modules, units, etc., described above can be implemented by computer program modules.

[0157] In such an embodiment, when the computer program is executed by the processor 401, it performs the functions defined in the system of this embodiment of the invention. According to embodiments of the invention, the systems, devices, apparatuses, modules, units, etc., described above can be implemented by computer program modules.

[0158] According to embodiments of the present invention, program code for executing the computer programs provided in the embodiments of the present invention can be written in any combination of one or more programming languages. Specifically, these computational programs can be implemented using high-level procedural and / or object-oriented programming languages, and / or assembly / machine languages. Programming languages ​​include, but are not limited to, languages ​​such as Java, C++, "C", or similar programming languages. The program code can be executed entirely on the user's computing device, partially on the user's device, partially on a remote computing device, or entirely on a remote computing device or server. In cases involving remote computing devices, the remote computing device can be connected to the user's computing device via any type of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computing device (e.g., via the Internet using an Internet service provider).

[0159] Those skilled in the art will understand that the features described in the various embodiments of the present invention can be combined and / or combined in various ways, even if such combinations or combinations are not explicitly described in the present invention. In particular, the features described in the various embodiments of the present invention can be combined and / or combined in various ways without departing from the spirit and teachings of the present invention. All such combinations and / or combinations fall within the scope of the present invention.

[0160] The embodiments of the present invention have been described above. However, these embodiments are merely illustrative and not intended to limit the scope of the invention. Although various embodiments have been described above, this does not mean that the measures in the various embodiments cannot be used advantageously in combination. Various substitutions and modifications can be made by those skilled in the art without departing from the scope of the invention, and all such substitutions and modifications should fall within the scope of the invention.

Claims

1. A method for intelligent interpretation of remote sensing images based on Kubernetes, characterized in that, The method includes: Based on the original remote sensing image, a ground feature heat map is generated, which represents the computational load distribution of different regions of the original remote sensing image; Based on the ground feature heat map, the original remote sensing image is divided into multiple sub-task blocks to balance the computational load of each sub-task block. Parallel interpretation and reasoning are performed on each of the sub-task blocks to obtain the reasoning results for each sub-task block, and the reasoning results carry global location information in the original remote sensing image; Based on the global location information of the reasoning results in the original remote sensing image, identify multiple reasoning results corresponding to the same target within the overlapping area of ​​adjacent sub-task blocks; Based on the multiple inference results, an interpretation result covering the original remote sensing image is generated.

2. The method according to claim 1, characterized in that, The process of generating a ground feature heatmap based on the original remote sensing imagery includes: Obtain the edge feature density of densely populated areas of man-made features in the original remote sensing image; Obtain the vegetation index of the areas in the original remote sensing image where land features need to be finely identified; The relative computational load of each pixel position in the original remote sensing image is calculated based on a weighted combination of the edge feature density and the vegetation index. The relative calculated load is added to the basic load constant to obtain the ground feature heat map.

3. The method according to claim 1, characterized in that, The step of dividing the original remote sensing image into multiple sub-task blocks based on the ground feature heat map, so that the computational load of each sub-task block is balanced, includes: The original remote sensing image is iteratively segmented; In each iteration, the total heatmap value of the current block is calculated; When the total heatmap value exceeds a preset threshold, the current block will be further divided; The segmentation is terminated when the total heatmap value of all sub-blocks is lower than the preset threshold.

4. The method according to claim 1, characterized in that, The parallel interpretation and reasoning of each subtask block to obtain the reasoning result of each subtask block includes: Publish the metadata descriptors of each of the subtask blocks to the message queue; The metadata descriptor is obtained from the message queue through the task consumer program; Create a container group for each of the aforementioned metadata descriptors; The container group is scheduled to an available graphics processor node, which is a compute node in a Kubernetes cluster; The inference operation of the preset deep learning model is executed on the graphics processor node.

5. The method according to claim 4, characterized in that, The step of scheduling the container group to an available graphics processor node includes: Obtain the hardware topology information of each graphics processor node in the cluster; Calculate a comprehensive score for each graphics processor node, which is positively correlated with the interconnect bandwidth between graphics processors within the node and negatively correlated with the number of network hops across nodes; The graphics processor node with the highest overall score is selected as the scheduling target for the container group.

6. The method according to claim 1, characterized in that, Based on the global location information of the inference results in the original remote sensing image, multiple inference results corresponding to the same target within the overlapping area of ​​adjacent sub-task blocks are identified, including: Perform geographic coordinate remapping correction on each of the inference results to obtain the corrected target location; Based on the corrected target location, identify multiple corrected inference results corresponding to the same target within the overlapping area of ​​adjacent subtask blocks.

7. The method according to claim 6, characterized in that, The generation of interpretation results covering the original remote sensing image based on the multiple inference results includes: Obtain the confidence score for each of the corrected inference results; Based on the confidence scores, the multiple corrected inference results are weighted and fused. The fused single result is used as the final detection result within the overlapping region; Based on the final detection results, an interpretation result covering the original remote sensing image is generated.

8. The method according to claim 7, characterized in that, The formula for calculating the weighted fusion is as follows: in, This represents the pixel value at position (x, y) after fusion. This represents the confidence level of the i-th corrected inference result. Let represent the detection value of the i-th corrected inference result at position (x, y). represents the geographic coordinate remapping mask value of the i-th corrected inference result, and n represents the number of subtask blocks that produce detection results for the same target.

9. A Kubernetes-based intelligent interpretation device for remote sensing images, characterized in that, The device includes: The heat map generation module is used to generate a ground feature heat map based on the original remote sensing image. The ground feature heat map represents the distribution of computational load in different areas of the original remote sensing image. The task segmentation module is used to segment the original remote sensing image into multiple sub-task blocks based on the ground feature heat map, so that the computational load of each sub-task block is balanced. The parallel inference module is used to perform parallel interpretation and inference on each of the sub-task blocks to obtain the inference result of each sub-task block, and the inference result carries global location information in the original remote sensing image. The result recognition module is used to identify multiple inference results corresponding to the same target within the overlapping area of ​​adjacent sub-task blocks based on the global location information of the inference results in the original remote sensing image. The result generation module is used to generate interpretation results covering the original remote sensing image based on the multiple inference results.

10. An electronic device, characterized in that, include: At least one processor; At least one memory, wherein the at least one memory stores computer program instructions; When the computer program instructions are executed by the at least one processor, the electronic device performs the method of any one of claims 1 to 8.

Images