Intelligent extraction of large remote sensing images by large model cross-protocol conversion method and system

Abstract

The application belongs to the technical field of large model cross-protocol conversion, and particularly relates to a large model cross-protocol conversion method and system for intelligent extraction of super large remote sensing images, comprising the following steps: S1. standardized interception and preprocessing of different client heterogeneous requests; S2. single request channel establishment based on dynamic client instances; S3. heterogeneous large model bidirectional protocol reconstruction and streaming data translation; S4. full link monitoring and resource recycling; S5. intelligent dynamic slicing and spatio-temporal context reorganization for super large remote sensing images; through constructing an intelligent protocol recognition and conversion mechanism, the application can automatically recognize the original protocol format and uniformly map it to the target model protocol for the super large remote sensing image processing request initiated by different clients. In the whole conversion chain, the system ensures the preservation and unification of the input end original image logic and the output end analysis result format, and improves the compatibility, flexibility and scalability of the intelligent surveying and mapping system when processing super large scale remote sensing data.

Description

Technical Field

[0001] This application belongs to the field of large model cross-protocol conversion technology, specifically involving a method and system for intelligent extraction and cross-protocol conversion of large models from ultra-large remote sensing images. Background Technology

[0002] In recent years, the rapid development of high-resolution Earth observation technology has greatly promoted the acquisition of satellite remote sensing data (such as Gaofen series, Sentinel, Maxar, etc.) and UAV mapping data, resulting in data exhibiting significant characteristics of "ultra-large scale" and "ultra-long strip-shaped". The vertical length of a single ultra-large remote sensing image (strip imagery) often reaches tens of thousands or even hundreds of thousands of pixels, and the file size can easily reach GB or even TB levels, containing extremely rich surface details and macro-geographic context information. These images play an irreplaceable and crucial role in long-distance linear engineering monitoring (such as inspection of power lines, railways, and oil pipelines), large-scale river evolution analysis, and refined land resource surveys. However, although current multimodal large models (VLMs) demonstrate excellent capabilities in image understanding and analysis, they face a serious "input bottleneck" challenge when processing these ultra-large remote sensing images. The visual input windows of mainstream large models (such as GPT-5, Claude 4.5, Gemini 3.1, etc.) all have strict hard limitations, typically supporting only image input within a few thousand pixels. This means that directly inputting ultra-large imagery into the model will lead to severe pixel compression, resulting in a significant loss of ground feature details and accuracy; or, due to the excessively large amount of Base64 encoded data, it will directly trigger a "ContextOverflow" error, making the model unable to process it. Simultaneously, this traditional full-map input method exceeds the memory capacity of existing inference servers, causing a severe imbalance in computing resources. Furthermore, to adapt to the model's input limitations, existing tiling methods are usually performed by the client, but under different model API interfaces, the required tiling strategies, overlap requirements, and logic for preserving geographic coordinate reference systems vary, making it easy to lose or fail to accurately reconstruct geospatial association information during processing.

[0003] In the intelligent extraction of information from such large-scale remote sensing images, a complex process of "segmented parsing and global aggregation" is typically required. During this process, the heterogeneity of API protocols from different vendors is further amplified, becoming a core obstacle to technology implementation. While some third-party encapsulation libraries or middleware have emerged to attempt unified calls to some mainstream APIs, these solutions typically have limited coverage, are outdated, and struggle to fully accommodate the latest protocol changes from all vendors, let alone seamlessly support emerging or privately deployed models. More importantly, most of these existing protocol conversion tools are designed for pure text-based scenarios and do not fully consider the unique geospatial attributes of remote sensing images (such as coordinate systems and projection information) and the need for splitting and reassembling ultra-long pixel streams. Current technical solutions generally lack an intelligent middleware capable of sensing the characteristics of remote sensing data and automating the entire conversion process from "image segmentation to protocol adaptation to feature extraction to result fusion." This makes it difficult for intelligent surveying and mapping systems to flexibly switch to more cost-effective or more specific capability-advantageous model clusters when processing ultra-large remote sensing images, which seriously limits the efficiency and robustness of intelligent extraction of remote sensing big data and hinders the in-depth development and large-scale application of artificial intelligence technology in the vertical field of intelligent surveying and mapping. Summary of the Invention

[0004] To address the aforementioned problems, this invention provides a method and system for converting cross-protocol large-scale model API requests adapted for remote sensing image extraction. This method, by constructing an intelligent protocol identification and conversion mechanism, can automatically identify the original protocol format and uniformly map it to the target model protocol for ultra-large remote sensing image processing requests initiated by different clients. The technical solution is as follows:

[0005] A method for intelligent extraction and cross-protocol conversion of large models from ultra-large remote sensing images includes the following steps:

[0006] S1. Standardized interception and preprocessing of heterogeneous requests from different clients;

[0007] S2. Establishment of a single request channel based on dynamic client instances, including instantiating an independent network object responsible only for the lifecycle of the current request using an asynchronous context manager for each validated API request;

[0008] The client is configured with timeout parameters optimized for long spatiotemporal inference tasks to ensure that the connection will not be dropped due to the client’s active timeout when the model is performing complex spatial index calculations or trajectory analysis.

[0009] This independent client initiates asynchronous streaming POST requests to heterogeneous backend models, establishing a stable data transmission channel;

[0010] S3. Heterogeneous large-scale model bidirectional protocol reconstruction and streaming data translation, including setting up row-level buffers. Once the backend model starts responding, an asynchronous generator is started to enter the streaming data processing loop, which reads the binary data stream flowing in from the TCP connection in a loop. By recognizing newline characters, the continuous byte stream is precisely cut into independent SSE event lines, and heartbeat packets and invalid blank lines are automatically filtered out to extract valid data frames containing JSON payloads. For each valid JSON data frame, the built-in dynamic field mapping engine will translate it in real time according to the differences between the source protocol and the target protocol. For models with reasoning capabilities, the system executes a unique implicit thought chain CoT injection logic. Dual channels simultaneously listen to the "content" and "reasoning_content" fields in the data packets.

[0011] S4. End-to-end monitoring and resource recovery;

[0012] S5. Intelligent dynamic slicing and spatiotemporal context reorganization for ultra-large remote sensing images.

[0013] Preferably, step S1 involves standardized interception and preprocessing of heterogeneous requests from different clients:

[0014] S11. When an inbound HTTP request is detected, its URL path characteristics and multimodal payload attributes are parsed in real time, and the source protocol type is automatically locked by identifying specific characteristic patterns;

[0015] S12. Start the multi-dimensional verification engine. While completing the API Key legality verification, perform deep cleaning of the request body for the remote sensing image parsing task, remove redundant fields and extract core spatiotemporal prompts, ultra-large image data streams or Base64 encoded objects.

[0016] S13. These heterogeneous parameters are standardized and encapsulated into a common data object in the intermediate layer.

[0017] Preferably, when each independent streaming request is initiated, a dedicated asynchronous HTTP client object is dynamically instantiated, and this object is confined to the entire lifecycle of the current request. The specific steps are as follows:

[0018] (a) Create a new asynchronous HTTP client instance at the entry point of the streaming request processing, which is configured with independent connection timeout, retry strategy and protocol parameters;

[0019] (b) Use context management mechanisms to ensure that the client instance serves only a single streaming response forwarding process, and automatically close the connection and release resources when the response ends normally, the user cancels, or an exception occurs;

[0020] (c) Based on the network location identifier, model name, or unique request identifier of the target backend service, implement client group reuse with limited granularity to optimize connection establishment overhead while ensuring isolation;

[0021] (d) Embed comprehensive exception capture and recovery logic in the streaming data forwarding loop. When an exception is detected, actively push a termination signal to the client and record detailed diagnostic information.

[0022] Preferably, when the model is detected to be in the "deep thinking" stage, that is, when "reasoning_content" is continuously output and "content" is temporarily empty, these originally invisible reasoning texts are automatically intercepted and marked as standard text streams and injected into the "content" channel;

[0023] When the backend sends the "[DONE]" signal, it strictly follows the Anthropic protocol specification to generate a four-way handshake termination sequence of "content_block_stop" -> "message_delta" -> "message_stop" to ensure that the client disconnects smoothly. If a network error or parsing error is encountered, a standard "error" event is synthesized and the channel is closed to prevent the client from hanging or crashing.

[0024] Preferred method: S4 end-to-end monitoring and resource recovery.

[0025] S41. For any concurrent request Let the timestamp of the request to enter the system be... The data stream ends at the timestamp of the first token (first character) returned in the stream. The data stream end timestamp is The global middleware collects and calculates key performance indicators in real time, including first-word latency. Total transmission time :

[0026] ;

[0027] ;

[0028] S42. The metadata vector of the request Write to the in-memory time-series database for real-time updates of the service load heatmap for the most recent 24 hours on the visual operations and maintenance dashboard;

[0029] S43. Once the streaming generator finishes execution, whether it ends normally or due to abnormal client disconnection, the previously created "AsyncClient" context will automatically trigger the exit mechanism, forcibly calling the "aclose()" method to completely release the underlying TCP connection and file descriptor.

[0030] Preferably, step S5 includes: image size perception and dynamic calculation of slice parameters:

[0031] Let the input original ultra-large remote sensing image be I, and its resolution and size be denoted as width W and height H. Let the preset input threshold or maximum token input threshold of the target extraction large model protocol be... ,when When this occurs, dynamic slicing is triggered:

[0032] Set the size of a single slice to S, satisfying Let the overlap of adjacent slices be in pixels. Calculate the step size of the sliding window. The total number of slices generated in the length and width directions of the slice sequence. , The calculation is as follows:

[0033] ;

[0034] Multi-graph sequence generation and spatiotemporal offset mapping table construction:

[0035] The original image I was cut into a total of subgraph sequence set Simultaneously, the middleware layer synchronously builds and maintains a spatiotemporal offset mapping table to record any subgraph. Local offset coordinates relative to the global top-left origin of the original image ;

[0036] Cross-protocol concurrent inference and local result generation:

[0037] For the set of subgraph sequences The target large model feature extraction function is input using a batch asynchronous request stream approach. Perform inference to obtain the set of local feature analysis results for the k-th subgraph. :

[0038] ;

[0039] Among them, the The extracted targets are all based on the local coordinate system of the current subgraph;

[0040] Inverse geographic coordinate derivation and spatial logic integration;

[0041] After extracting the local results, a preset affine transformation function is used. Combined with the spatiotemporal offset mapping table and the global geographic coordinate reference matrix of the original image. Converting local coordinates to global true geographic coordinates, the global stitching result of the k-th submap. Represented as:

[0042] .

[0043] Preferred method: Spatial deduplication and standardization of overlapping areas:

[0044] The global stitching results of all submaps are aggregated and merged. A spatial deduplication and geometric fusion algorithm Ω is introduced to eliminate redundancy and fragmentation distortion, generating a standardized mapping report with global geographic semantic consistency. :

[0045] .

[0046] A large-scale remote sensing image intelligent extraction and cross-protocol conversion system includes a standardized interception and preprocessing module, a single-request channel establishment module based on dynamic client instances, a heterogeneous large-scale image bidirectional protocol reconstruction and streaming data translation module, a full-link monitoring and resource recovery module, and a dynamic slicing and spatiotemporal context reorganization module.

[0047] Standardized interception and preprocessing module: Enables unified access to large models of different protocols, and achieves automatic identification, parameter filtering and extraction of different protocols through path and other rule matching;

[0048] A single-request channel establishment module based on dynamic client instances: For each verified request, an independent, independent object responsible only for the lifecycle of the current request is instantiated using a Python asynchronous context manager; at the same time, timeout parameters are dynamically configured to ensure that the connection will not be disconnected due to the client's active timeout when the model is performing complex spatial index calculations or trajectory analysis.

[0049] Heterogeneous large model bidirectional protocol reconstruction and streaming data translation module: It realizes real-time seamless translation between heterogeneous protocols such as Anthropic and OpenAI, and automatically injects the implicit inference process of the model into the standard text stream to improve the interpretability of the output. At the same time, it strictly follows the target protocol specifications to perform handshake start-up, smooth disconnection and graceful degradation in case of anomalies, thereby ensuring that the client can stably and transparently access various multi-source heterogeneous large models without any modification.

[0050] End-to-end monitoring and resource reclamation module: At the end of the conversion, the timely "death" of the streaming conversion handshake is achieved, completely releasing the underlying TCP connection and file descriptor, and realizing precise monitoring of the entire lifecycle of the conversion;

[0051] Dynamic tiling and spatiotemporal context reorganization module: Utilizing the aforementioned real-time streaming conversion mechanism, intelligent tiling and dynamic calculation of ultra-large remote sensing images are performed to realize concurrent inference and result integration of image information. Through coordinate inverse solution and spatial deduplication, standardized output of results is achieved.

[0052] Compared with the prior art, the beneficial effects of this application are as follows:

[0053] (1) Intelligent identification and adaptive conversion of large models with heterogeneous protocols are realized. This invention dynamically identifies the API protocol formats of different large model vendors such as Anthropic and OpenAI by analyzing the characteristics of client AI request endpoints, request headers and request bodies, without the need for manual intervention.

[0054] (2) A highly reliable streaming transmission guarantee mechanism based on request-level unit isolation was established. For spatiotemporal computing tasks with long delays and heavy loads, such as ultra-large remote sensing image analysis, this invention employs a connection isolation strategy implemented through asynchronous context management, significantly improving the system's anti-interference capability and stability when processing streaming API responses. This mechanism effectively eliminates network link errors, response truncation, or SSE packet loss caused by global connection pool state contention, ensuring the continuity of image data extraction tasks and the robustness of system operation in large-scale concurrent access scenarios at the city level.

[0055] (3) Seamless integration and transparent scheduling for multi-source heterogeneous models are achieved. The cross-protocol unified translation engine constructed in this invention enables surveying terminal applications to call underlying model clusters with different performance levels using standardized logic, achieving "black box" processing of APIs from different vendors. This solves the industry problem of escalating system maintenance complexity caused by frequent switching between Claude, GPT, Gemini, or privately deployed models in complex operations such as emergency monitoring and land cover surveys. By shielding the differences in underlying protocols, this invention significantly reduces the R&D and operation and maintenance costs of enterprises, achieving an optimal dynamic balance between inference accuracy and calling costs.

[0056] (4) It breaks through the pixel limitation and token overflow bottleneck of ultra-large remote sensing images at the input end of large models. Combining the built-in dynamic tiling processing and spatiotemporal context reorganization logic, this invention enables long strip images that were originally limited by the size of the model input window to complete intelligent recognition while maintaining the original resolution. This innovation not only fundamentally solves the "context overrun" problem caused by excessive Base64 encoding, but also ensures the semantic consistency of geographic elements at the edge of the tile, greatly expanding the breadth and depth of application of large models in long-distance linear engineering monitoring and large-scale natural resource surveys. Attached Figure Description

[0057] Figure 1 A method and system flowchart for intelligent extraction and cross-protocol conversion of large models from ultra-large remote sensing images;

[0058] Figure 2 Flowchart of the large-model streaming request unit isolation mechanism. Detailed Implementation

[0059] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments.

[0060] A method for intelligent extraction and cross-protocol conversion of large models from ultra-large remote sensing images includes the following steps:

[0061] (1) Standardized interception and preprocessing of heterogeneous requests from different clients:

[0062] Deployed as a high-performance unified gateway between clients and heterogeneous large-scale model clusters, it establishes a standardized interception mechanism based on dynamic route matching. When the system detects an inbound HTTP request, it parses its URL path characteristics and multimodal payload attributes in real time, automatically identifying the source protocol type by recognizing characteristic patterns such as " / v1 / messages" or " / v1 / chat / completions". The system then activates a multi-dimensional verification engine to perform API key validity verification and deep cleaning of the request body for remote sensing image analysis tasks, removing redundant fields and extracting core spatiotemporal prompts, ultra-large image data streams, or Base64 encoded objects. By standardizing and encapsulating these heterogeneous parameters into a common data object in the intermediate layer, the system lays a unified data foundation for subsequent cross-protocol forwarding and spatiotemporal information processing.

[0063] (2) Establishment of a single request channel based on a dynamic client instance:

[0064] To address the high latency and heavy load characteristics of remote sensing image inference tasks, this invention abandons the traditional global connection pool reuse model and adopts a strict request-level unit isolation strategy to completely eliminate the risks of state races and data truncation in streaming responses. For each validated API request, the system uses Python's asynchronous context manager to instantiate an independent "httpx.AsyncClient" object that is only responsible for the lifecycle of the current request. This client is configured with timeout parameters optimized for long-term spatiotemporal inference tasks, ensuring that the connection will not be broken due to the client's active timeout when the model is performing complex spatial index calculations or trajectory analysis. Subsequently, the system uses this independent client to initiate asynchronous streaming POST requests to heterogeneous backend models, establishing a stable data transmission channel. Specifically, this module dynamically instantiates a dedicated asynchronous HTTP client object when each independent streaming request is initiated and confines this object to the entire lifecycle of the current request. The specific steps are as follows:

[0065] (a) Create a new asynchronous HTTP client instance at the entry point of the streaming request processing, which is configured with independent connection timeout, retry strategy and protocol parameters (preferably supporting HTTP / 2).

[0066] (b) Use context management mechanisms to ensure that the client instance serves only a single streaming response forwarding process, and automatically close the connection and release resources when the response ends normally, the user cancels, or an exception occurs;

[0067] (c) Avoid using globally shared or connection pooled client instances to eliminate stream object contention caused by incomplete consumption of previous streaming responses, abnormal interruptions, or connection state remnants.

[0068] (d) Based on the network location identifier, model name, or unique request identifier of the target backend service, implement client group reuse with limited granularity to optimize connection establishment overhead while ensuring isolation;

[0069] (e) Embed comprehensive exception capture and recovery logic in the streaming data forwarding loop. When exceptions such as StreamConsumed, IncompleteRead, ChunkedEncodingError or net::ERR_INCOMPLETE_CHUNKED_ENCODING on the browser side are detected, actively push termination signals (including empty data blocks and [DONE] events) to the client and record detailed diagnostic information.

[0070] Through the above isolation mechanism, the present invention significantly improves the transmission stability and robustness of the proxy system when handling Anthropic protocol compatible or other long-latency streaming APIs, and effectively eliminates network errors and response truncation caused by shared client state contention.

[0071] (3) Reconstruction of bidirectional protocols and translation of streaming data in heterogeneous large models:

[0072] Once the backend model begins responding, the system starts an asynchronous generator to enter a streaming data processing loop. The system maintains a row-level buffer, continuously reading the binary data stream flowing in from the TCP connection. To address the common packet fragmentation phenomenon in network transmission, the system accurately segments the continuous byte stream into independent SSE event lines by recognizing newline characters, automatically filters out heartbeat packets and invalid blank lines, and extracts valid data frames containing JSON payloads.

[0073] For each frame of valid JSON data, the system's built-in dynamic field mapping engine performs real-time translation based on the differences between the source and target protocols. Taking a client sending Anthropic format data via OpenAI and then re-transforming it into Anthropic data as an example, when the system receives the first valid data packet, it doesn't forward it directly. Instead, it first constructs and sends a "message_start" event conforming to the Anthropic specification to complete a virtual handshake. Subsequently, the system continuously parses the OpenAI "delta.content" field, reassembles it into a `content_block_delta` event, and pushes it to the client. The specific steps are as follows:

[0074] The client sends an Anthropic format request to the gateway's / v1 / messages endpoint. The gateway identifies the protocol type as Anthropic, parses the model name (e.g., claude-opus-4-5), queries the mapping table to obtain the actual backend model (e.g., GLM-4.7), performs format conversion, converts the system field to messages[0], sets role to system, retains the messages array, and converts stop_sequences to the stop parameter; it sends the converted OpenAI format request to the GLM-4.7 API, receives the OpenAI format response from GLM-4.7, performs format conversion on the response, converts choices[0].message.content to content[0].text, and converts finish_reason to stop_reason; finally, it returns an Anthropic format response to the client.

[0075] The mapping table is in JSON structure:

[0076] {"ANTHROPIC_DEFAULT_HAIKU_MODEL":"glm-4.5-air", "ANTHROPIC_DEFAULT_SONNET_MODEL":"glm-4.7", "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-4.7"}

[0077] During this process, for models with reasoning capabilities (such as DeepSeek-R1), the system executes a unique implicit thought chain (CoT) injection logic. The system simultaneously monitors the "content" (standard answer) and "reasoning_content" (reasoning content) fields in data packets via dual channels. When the system detects that the model is in a "deep thinking" phase (i.e., "reasoning_content" is continuously output while "content" is temporarily empty), it automatically intercepts this previously invisible reasoning text, marks it as standard text stream, and injects it into the "content" channel. This mechanism allows the GIS client to view the complete thought process of the model's path planning or area retrieval in real time in the dialog box without any upgrades, greatly improving the transparency and interpretability of the decision-making system. When the backend sends the "[DONE]" signal, the system strictly follows the Anthropic protocol specification, generating a four-way handshake termination sequence of "content_block_stop" -> "message_delta" -> "message_stop" to ensure a smooth client disconnection. If a network anomaly or parsing error is encountered, the system synthesizes a standard "error" event and closes the channel to prevent client hangs or crashes.

[0078] (4) End-to-end monitoring and resource recovery:

[0079] Throughout the entire streaming process described above, for any concurrent request... Let the timestamp of the request to enter the system be... The data stream ends at the timestamp of the first token (first character) returned in the stream. The data stream end timestamp is The global middleware collects and calculates key performance indicators in real time, including first-word latency. Total transmission time :

[0080] ;

[0081] ;

[0082] Subsequently, the system will send the request's metadata vector The data is written to an in-memory time-series database, providing a real-time update of the service load heatmap for the most recent 24 hours on a visual operations dashboard. Once the streaming generator finishes execution, whether it terminates normally or due to an abnormal client disconnection, the previously created "AsyncClient" context automatically triggers an exit mechanism, forcibly calling the "aclose()" method to completely release the underlying TCP connection and file descriptors. This automated resource reclamation mechanism ensures that the system maintains zero memory leaks and high service availability even when facing large-scale concurrent access at the city level.

[0083] (5) Intelligent dynamic tiling and spatiotemporal context reconstruction for ultra-large remote sensing images:

[0084] To address the issue of large strip-shaped remote sensing images easily triggering model token overflow or pixel limitations, the system constructs an intelligent dynamic slicing module that perceives image features. The module content is as follows:

[0085] ① Image size perception and dynamic calculation of slice parameters:

[0086] Let I be the input original ultra-large remote sensing image, and let W be its width and H be its height. Let the maximum pixel / Token input threshold preset by the target extraction large model protocol be... ,when When this happens, the dynamic slicing module is triggered.

[0087] Set the size of a single slice to S (satisfying) To prevent edge features from breaking, the preset overlap of adjacent slices in pixels is [value missing]. The system calculates the step size of the sliding window. The total number of slices generated in the length and width directions of the slice sequence. , The calculation is as follows:

[0088] ;

[0089] ② Generation of multiple graph sequences and construction of spatiotemporal offset mapping table:

[0090] Based on the above parameters, the original image I is cut into a total of subgraph sequence set Simultaneously, the middleware layer synchronously builds and maintains a spatiotemporal offset mapping table to record any subgraph. Local offset coordinates relative to the global top-left origin of the original image .

[0091] ③ Cross-protocol concurrent inference and local result generation:

[0092] For the set of subgraph sequences The target large model feature extraction function is input using a batch asynchronous request stream approach. Perform inference. Obtain the set of local feature analysis results for the k-th subgraph. :

[0093] ;

[0094] Among them, the The extracted targets (such as polygonal nodes like roads and text boxes) are all based on the local coordinate system of the current subgraph.

[0095] ④ Geographic coordinate inverse solution and spatial logic stitching:

[0096] After extracting the local results, a preset affine transformation function is used. Combined with the spatiotemporal offset mapping table and the global geographic coordinate reference matrix of the original image. This converts local coordinates to global true geographic coordinates. The global stitching result for the k-th subgraph. Represented as:

[0097] ;

[0098] ⑤ Spatial deduplication and standardized output of overlapping areas:

[0099] The global stitching results of all submaps are aggregated and merged. Due to the defined overlap degree O, overlapping areas in the seams exhibit repetitive characteristics. Therefore, the system introduces a spatial deduplication and geometric fusion algorithm Ω to eliminate redundancy and breakage distortion, ultimately generating a standardized mapping report with global geographic semantic consistency. :

[0100] .

[0101] A large-scale remote sensing image intelligent extraction and cross-protocol conversion system includes: a standardized interception and preprocessing module, a single-request channel establishment module based on dynamic client instances, a heterogeneous large-scale image bidirectional protocol reconstruction and streaming data translation module, a full-link monitoring and resource recovery module, and a dynamic slicing and spatiotemporal context reorganization module.

[0102] Standardized interception and preprocessing module: Enables unified access to large models of different protocols, and achieves automatic identification, parameter filtering and extraction of different protocols through path and other rule matching;

[0103] A single-request channel establishment module based on dynamic client instances: For each verified request, an independent, independent object responsible only for the lifecycle of the current request is instantiated using a Python asynchronous context manager; at the same time, timeout parameters are dynamically configured to ensure that the connection will not be disconnected due to the client's active timeout when the model is performing complex spatial index calculations or trajectory analysis.

[0104] Heterogeneous large model bidirectional protocol reconstruction and streaming data translation module: It realizes real-time seamless translation between heterogeneous protocols such as Anthropic and OpenAI, and automatically injects the implicit inference process of the model into the standard text stream to improve the interpretability of the output. At the same time, it strictly follows the target protocol specifications to perform handshake start-up, smooth disconnection and graceful degradation in case of anomalies, thereby ensuring that the client can stably and transparently access various multi-source heterogeneous large models without any modification.

[0105] End-to-end monitoring and resource reclamation module: At the end of the conversion, the timely "death" of the streaming conversion handshake is achieved, completely releasing the underlying TCP connection and file descriptor, and realizing precise monitoring of the entire lifecycle of the conversion;

[0106] Dynamic tiling and spatiotemporal context reorganization module: Utilizing the aforementioned real-time streaming conversion mechanism, intelligent tiling and dynamic calculation of ultra-large remote sensing images are performed to realize concurrent inference and result integration of image information. Through coordinate inverse solution and spatial deduplication, standardized output of results is achieved.

[0107] The present invention also provides a computer-readable storage medium, wherein the computer-readable storage medium stores a program for a method of intelligent extraction of large models and cross-protocol conversion of ultra-large remote sensing images, which, when executed by a processor, implements the steps of the method of intelligent extraction of large models and cross-protocol conversion of ultra-large remote sensing images as described above.

[0108] Of course, those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware (such as a processor, controller, etc.). The program can be stored in a computer-readable storage medium, and when executed, it can include the processes described in the above method embodiments. The computer-readable storage medium can be a memory, magnetic disk, optical disk, etc.

[0109] The above description of the disclosed embodiments enables those skilled in the art to make or use the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the invention. Therefore, the invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A method for intelligent extraction and cross-protocol conversion of large models from ultra-large remote sensing images, characterized in that, Includes the following steps: S1. Standardized interception and preprocessing of heterogeneous requests from different clients; S2. Establishment of a single request channel based on dynamic client instances, including instantiating an independent network object responsible only for the lifecycle of the current request using an asynchronous context manager for each validated API request; The client is configured with timeout parameters optimized for long spatiotemporal inference tasks to ensure that the connection will not be dropped due to the client’s active timeout when the model is performing complex spatial index calculations or trajectory analysis. By using an independent client to initiate asynchronous streaming POST requests to heterogeneous backend models, a stable data transmission channel is established. S3. Heterogeneous large-scale model bidirectional protocol reconstruction and streaming data translation, including setting up row-level buffers. Once the backend model starts responding, an asynchronous generator is started to enter the streaming data processing loop, which reads the binary data stream flowing in from the TCP connection in a loop. By recognizing newline characters, the continuous byte stream is precisely cut into independent SSE event lines, and heartbeat packets and invalid blank lines are automatically filtered out to extract valid data frames containing JSON payloads. For each valid JSON data frame, the built-in dynamic field mapping engine will translate it in real time according to the differences between the source protocol and the target protocol. For models with reasoning capabilities, the system executes a unique implicit thought chain CoT injection logic. Dual channels simultaneously listen to the "content" and "reasoning_content" fields in the data packets. S4. End-to-end monitoring and resource recovery; S5. Intelligent dynamic slicing and spatiotemporal context reorganization for ultra-large remote sensing images.

2. The method for intelligent extraction and cross-protocol conversion of large models from ultra-large remote sensing images according to claim 1, characterized in that, Step S1: Standardized interception and preprocessing of heterogeneous requests from different clients: S11. When an inbound HTTP request is detected, its URL path characteristics and multimodal payload attributes are parsed in real time, and the source protocol type is automatically locked by recognizing the specified characteristic patterns; S12. Start the multi-dimensional verification engine. While completing the API Key legality verification, perform deep cleaning of the request body for the remote sensing image parsing task, remove redundant fields and extract core spatiotemporal prompts, ultra-large image data streams or Base64 encoded objects. S13. By uniformly mapping and encapsulating heterogeneous parameters such as text prompts, image data streams, and additional spatial metadata from different sources and in different formats into a common data object in the middle layer.

3. The method for intelligent extraction and cross-protocol conversion of large models from ultra-large remote sensing images according to claim 1, characterized in that, When each independent streaming request is initiated, a dedicated asynchronous HTTP client object is dynamically instantiated and confined to the entire lifecycle of the current request. The specific steps are as follows: (a) Create a new asynchronous HTTP client instance at the entry point of the streaming request processing, which is configured with independent connection timeout, retry strategy and protocol parameters; (b) Use context management mechanisms to ensure that the client instance serves only a single streaming response forwarding process, and automatically close the connection and release resources when the response ends normally, the user cancels, or an exception occurs; (c) Avoid using globally shared or connection pooled client instances to eliminate stream object contention caused by incomplete consumption of previous streaming responses, abnormal interruptions, or connection state remnants. (d) Embed comprehensive exception capture and recovery logic in the streaming data forwarding loop. When an exception is detected, actively push a termination signal to the client and record detailed diagnostic information.

4. The method for intelligent extraction and cross-protocol conversion of large models from ultra-large remote sensing images according to claim 1, characterized in that, When the model is detected to be in the "deep thinking" stage, that is, when "reasoning_content" is continuously output and "content" is temporarily empty, the previously invisible reasoning text is automatically intercepted, marked as standard text stream and injected into the "content" channel; When the backend sends the "[DONE]" signal, it strictly follows the Anthropic protocol specification to generate a four-way handshake termination sequence of "content_block_stop" -> "message_delta" -> "message_stop" to ensure that the client disconnects smoothly. If a network error or parsing error is encountered, a standard "error" event is synthesized and the channel is closed to prevent the client from hanging or crashing.

5. The method for intelligent extraction and cross-protocol conversion of large models from ultra-large remote sensing images according to claim 1, characterized in that, S4 end-to-end monitoring and resource reclamation: S41. For any concurrent request Let the timestamp of the request to enter the system be... The data stream ends at the timestamp of the first token returned in the streaming mode. The data stream end timestamp is The global middleware collects and calculates key performance indicators in real time, including first-word latency. Total transmission time : ； ； S42. Transfer the requested metadata vector Write to an in-memory time-series database for real-time updates of service load heatmaps on the visual operations and maintenance dashboard; S43. Once the streaming generator finishes execution, whether it ends normally or due to abnormal client disconnection, the previously created "AsyncClient" context will automatically trigger the exit mechanism, forcibly calling the "aclose()" method to completely release the underlying TCP connection and file descriptor.

6. The method for intelligent extraction and cross-protocol conversion of large models from ultra-large remote sensing images according to claim 1, characterized in that, Step S5 includes: image size perception and dynamic calculation of slice parameters: Let the input original ultra-large remote sensing image be I, and its resolution and size be denoted as width W and height H. Let the maximum pixel input threshold or maximum token input threshold preset by the target extraction large model protocol be... ,when When this occurs, dynamic slicing is triggered: Set the size of a single slice to S, satisfying Let the overlap of adjacent slices be in pixels. Calculate the step size of the sliding window. The total number of slices generated in the length and width directions of the slice sequence. , The calculation is as follows: ； Multi-graph sequence generation and spatiotemporal offset mapping table construction: The original image I was cut into a total of subgraph sequence set Simultaneously, the middleware layer synchronously builds and maintains a spatiotemporal offset mapping table to record any subgraph. Local offset coordinates relative to the global top-left origin of the original image ; Cross-protocol concurrent inference and local result generation: For the set of subgraph sequences The target large model feature extraction function is input using a batch asynchronous request stream approach. Perform inference to obtain the set of local feature analysis results for the k-th subgraph. : ； Among them, the The extracted targets are all based on the local coordinate system of the current subgraph; Inverse geographic coordinate derivation and spatial logic integration; After extracting the local results, a preset affine transformation function is used. Combined with the spatiotemporal offset mapping table and the global geographic coordinate reference matrix of the original image. Converting local coordinates to global true geographic coordinates, the global stitching result of the k-th submap. Represented as: 。 7. The method for intelligent extraction and cross-protocol conversion of large models from ultra-large remote sensing images according to claim 6, characterized in that, Spatial deduplication and standardization of overlapping areas: The global stitching results of all submaps are aggregated and merged. A spatial deduplication and geometric fusion algorithm Ω is introduced to eliminate redundancy and fragmentation distortion, generating a standardized mapping report with global geographic semantic consistency. : 。 8. A large-scale remote sensing image intelligent extraction and cross-protocol conversion system, adapted to the method described in any one of claims 1-7, characterized in that, It includes a standardized interception and preprocessing module, a single request channel establishment module based on dynamic client instances, a heterogeneous large model bidirectional protocol reconstruction and streaming data translation module, a full-link monitoring and resource reclamation module, and a dynamic slicing and spatiotemporal context reorganization module; Standardized interception and preprocessing module: Enables unified access to large models of different protocols, and achieves automatic identification, parameter filtering and extraction of different protocols through path rule matching; A single-request channel establishment module based on dynamic client instances: For each verified request, an independent, independent object responsible only for the lifecycle of the current request is instantiated using a Python asynchronous context manager; at the same time, timeout parameters are dynamically configured to ensure that the connection will not be disconnected due to the client's active timeout when the model is performing complex spatial index calculations or trajectory analysis. Heterogeneous large model bidirectional protocol reconstruction and streaming data translation module: It realizes real-time seamless translation between Anthropic and OpenAI heterogeneous protocols, and automatically injects the implicit inference process of the model into the standard text stream to improve the interpretability of the output. At the same time, it strictly follows the target protocol specifications to perform handshake start-up, smooth disconnection and graceful degradation of anomalies, thereby ensuring that the client can stably and transparently access various multi-source heterogeneous large models without any modification. End-to-end monitoring and resource reclamation module: At the end of the conversion, the timely "death" of the streaming conversion handshake is achieved, completely releasing the underlying TCP connection and file descriptor, and realizing precise monitoring of the entire lifecycle of the conversion; Dynamic tiling and spatiotemporal context reorganization module: Utilizing a real-time streaming conversion mechanism, it performs intelligent tiling and dynamic calculation of ultra-large remote sensing images, realizes concurrent inference and result integration of image information, and achieves standardized output of results through coordinate inverse solution and spatial deduplication.

Images