Meteorological intelligent agent tool invocation and task orchestration method, system, device and medium for continuous meteorological field

Abstract

The application discloses a meteorological intelligent agent tool calling and task arrangement method, system, device and medium for a continuous weather field, the method comprising: pre-constructing a meteorological tool center, registering a complex scientific calculation model to the meteorological tool center to encapsulate a meteorological tool. An intelligent agent core controller analyzes a task instruction to convert it into a sub-task chain, calls a task planner to perform meteorological tool calling and arrangement based on the sub-task chain to form a task undirected graph, executes the meteorological tool according to the task undirected graph through an execution engine to obtain a continuous weather field, calls a semantic mapping module to convert the continuous weather field into a structured task risk semantic description, and generates a task strategy based on the structured task risk semantic description. In this way, the continuous field data is transferred in a link between the meteorological tool and the execution engine, the upper intelligent agent is only responsible for business semantic analysis, the intelligent agent can process the continuous field data, and the meteorological tool can be reused by the upper intelligent agent task.

Description

Technical Field

[0001] This application relates to the interdisciplinary field of artificial intelligence and scientific computing, and in particular to a method, system, device and medium for calling meteorological intelligent agent tools and scheduling tasks for continuous meteorological fields. Background Technology

[0002] In recent years, generative agents built upon large language models and multimodal models have demonstrated powerful capabilities in tasks such as information retrieval and code generation. However, existing agents can only process discrete, static symbolic information, and the supporting tool systems are built around text question answering, database querying, and code execution. When application scenarios expand to real-world physical scenarios with continuous spatial structures, strong spatiotemporal coupling, and dynamic evolutionary characteristics (such as meteorology, fluid mechanics, and climate prediction), generative agents cannot adapt to the task requirements of such scenarios due to the lack of native modeling capabilities and tool interfaces for high-dimensional, multivariable continuous spatiotemporal fields (such as temperature fields and wind fields). This makes it difficult for the predictive capabilities of existing generative agents to be reused for higher-level tasks.

[0003] Therefore, existing technologies still need to be improved and enhanced. Summary of the Invention

[0004] The technical problem to be solved by this application is to provide a method, system, device and medium for calling up meteorological intelligent agents and scheduling tasks for continuous meteorological fields, in order to address the shortcomings of the existing technology.

[0005] To address the aforementioned technical problems, the first aspect of this application provides a method for invoking and scheduling meteorological intelligent agents for continuous weather fields, wherein the method includes: Receive task instructions from users in natural language and decompose the high-level tasks corresponding to the task instructions into sub-task chains; Meteorological tools are selected from the meteorological tool center for each subtask in the subtask chain. The meteorological tools in the meteorological tool center inherit the native abstract interface that supports continuous meteorological fields and are configured with standardized descriptions. The standardized descriptions include input space, output space, meta-information, applicable conditions, quality metrics, and resource requirements. Generate an undirected graph of the task based on the dependencies between meteorological tools; Execute the meteorological tools corresponding to each subtask according to the undirected graph of the task to obtain a continuous meteorological field; The continuous meteorological field is converted into a structured task risk semantic description, and a task strategy is generated based on the structured task risk semantic description.

[0006] The method for invoking and scheduling meteorological intelligent agents for continuous weather fields, wherein the registration process of the meteorological tools specifically includes: Obtain a pre-built abstract interface that supports continuous weather fields as input / output objects; The meteorological model is controlled to inherit the abstract interface, and a standardized description is generated for the meteorological model through the abstract interface. Based on the standardized description, the meteorological model is registered with the meteorological tool center.

[0007] The method for invoking meteorological intelligent agents and orchestrating tasks for continuous weather fields, wherein selecting meteorological tools from the meteorological tool center for each subtask in the subtask chain specifically includes: For each subtask in the subtask chain, obtain the task requirements of the subtask; Determine the similarity between the task requirements and the metadata of meteorological tools in the meteorological tool center; Based on the similarity, meteorological tools are selected from the meteorological tool center for each subtask.

[0008] The method for invoking meteorological intelligent agents and orchestrating tasks for continuous meteorological fields, wherein selecting meteorological tools from the meteorological tool center for each sub-task based on the similarity specifically includes: Several candidate meteorological tools are selected from the meteorological tool center in descending order of similarity. Meteorological tools are selected from several candidate meteorological tools based on task priority and current system resource status.

[0009] The method for invoking and orchestrating meteorological intelligent agents for continuous meteorological fields, wherein generating an undirected task graph based on the dependencies between meteorological tools specifically includes: In accordance with the task order of the subtasks, the output descriptions of meteorological tools are matched with the input descriptions of downstream meteorological tools that are not bound to output descriptions in order to build data dependency edges between meteorological tools corresponding to the subtasks. Construct semantic dependency edges between meteorological tools and downstream meteorological tools that inherit their semantic results; Construct control dependency edges between meteorological tools and downstream meteorological tools that are triggered by them; An undirected graph of the task is generated based on the data dependency edges, semantic dependency edges, and control dependency edges.

[0010] The method for invoking and orchestrating meteorological intelligent agents for continuous meteorological fields, wherein the step of executing meteorological tools corresponding to each subtask according to the undirected task graph to obtain the continuous meteorological field specifically includes: For each task node in the undirected task graph, the initial in-degree of the task node is determined based on the upstream task node with which it has an edge. The task nodes with an initial in-degree of 0 and whose guard conditions are activated are added to the preparation set, wherein the task nodes in the preparation set are executed in parallel and / or in serial manner. Execute the meteorological tools corresponding to the task nodes in the preparation set, and decrement the initial in-degree of the downstream task nodes that have an edge with the task node by 1 after each task node is executed. Re-execute the process by adding the task nodes with an initial in-degree of 0 and activated guard conditions to the preparation set until all task nodes have been executed.

[0011] The method for invoking and orchestrating meteorological intelligent agents for continuous meteorological fields, wherein, in the process of executing meteorological tools corresponding to each subtask according to the undirected task graph to obtain the continuous meteorological field, the method further includes: The generation quality of the continuous meteorological field is checked to see if it meets the requirements. If the requirements are met, the continuous weather field will be output. If the requirements are not met, an iterative task node is generated, and the meteorological tools corresponding to each subtask are re-executed according to the undirected task graph by executing the iterative task node.

[0012] The method for invoking and orchestrating meteorological intelligent agents for continuous meteorological fields, wherein, in the process of executing meteorological tools corresponding to each subtask according to the undirected task graph to obtain the continuous meteorological field, the method further includes: After each task node in the undirected task graph is completed, the undirected task graph is dynamically updated based on the node's running status, the task conditions of the meteorological tool corresponding to the task node, the quality metric, and the required resources. The dynamic update includes one or more of the following: adding task nodes, deleting task nodes, redirecting data edges, and selecting branch paths.

[0013] The method for invoking meteorological intelligent agents and orchestrating tasks for continuous meteorological fields, wherein converting the continuous meteorological field into a structured task risk semantic description and generating a task strategy based on the structured task risk semantic description specifically includes: Extract the continuous task indicators from the continuous meteorological field and discretize the continuous task indicators into gridded task indicators; Spatiotemporal positioning is performed based on gridded task indicators to identify risk areas, and the risk level and confidence level of the risk areas are obtained. A structured semantic description of task risk is generated based on the risk area, risk level, and confidence level. The structured task risk semantic description is input into a large model, and the large model generates task strategies.

[0014] The second aspect of this application provides a meteorological intelligent agent tool invocation and task scheduling system for continuous weather fields, wherein the system includes: The core control layer of the intelligent agent is used to receive task instructions issued by the user in natural language and decompose the high-level task corresponding to the task instruction into a chain of sub-tasks. The task planning and orchestration layer is used to select meteorological tools from the meteorological tool center for each subtask in the subtask chain, and generate an undirected task graph based on the dependency relationship between the meteorological tools. The undirected task graph has subtasks as nodes and dependency relationships as edges. An execution engine is used to execute meteorological tools corresponding to each subtask according to the undirected graph of the task to obtain a continuous meteorological field. The risk semantic mapping and interaction layer is used to convert the continuous meteorological field into a structured task risk semantic description and generate a task strategy based on the structured task risk semantic description.

[0015] A third aspect of this application provides a computer-readable storage medium storing one or more programs that can be executed by one or more processors to implement the steps in the meteorological intelligent agent tool invocation and task orchestration method for continuous meteorological fields as described above.

[0016] A fourth aspect of this application provides a terminal device, which includes: a processor and a memory; The memory stores a computer-readable program that can be executed by the processor; When the processor executes the computer-readable program, it implements the steps in the meteorological intelligent agent tool invocation and task orchestration method for continuous meteorological fields as described above.

[0017] Beneficial effects: 1. This application proposes a generative agent construction method for continuous meteorological field modeling capabilities. It encapsulates complex scientific computing models into standardized meteorological tools. Continuous field data flows between the meteorological tools and the execution engine. The upper-layer agent is only responsible for business semantic parsing, enabling the agent to process continuous field data.

[0018] 2. Based on task requirements, this application retrieves meteorological tools from a meteorological tool center characterized by standardized descriptions, arranges them into a task undirected graph, and then calls computing resources to execute the retrieved meteorological tools according to the task undirected graph to obtain a continuous meteorological field, so that meteorological tools can be reused by upper-layer intelligent agents.

[0019] 3. The intelligent agent in this application can automatically select meteorological tools according to task requirements, data conditions and resource constraints. Compared with a fixed pipeline, the task execution efficiency can be improved by 30%-50%, and it can automatically deal with abnormal situations such as missing data and tool failure, which greatly improves the robustness of the system.

[0020] 4. This application encapsulates the risk semantic mapping model into a registerable and programmable tool node. After acquiring the continuous meteorological field, the risk semantic mapping model is triggered. The continuous meteorological field is transformed into a structured task risk semantic description through the risk semantic mapping model, so as to generate task strategies based on the structured task risk semantic description. This realizes the fully automated generation of task instructions from natural language to task strategies, eliminates the information barrier between numerical field and decision semantics, and significantly improves the usability and credibility of intelligent agents in real decision-making scenarios (such as disaster early warning and flight safety). Attached Figure Description

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

[0022] Figure 1 A flowchart illustrating the method for invoking and arranging meteorological intelligent agents for continuous meteorological fields, as provided in this application embodiment.

[0023] Figure 2 This is the overall framework diagram.

[0024] Figure 3 This is an example graph of an undirected graph for the task.

[0025] Figure 4 This is a diagram illustrating dynamic arrangement.

[0026] Figure 5 This is a flowchart illustrating the semantic mapping process.

[0027] Figure 6 This is a schematic diagram of the principle of a meteorological intelligent agent tool invocation and task orchestration system for continuous meteorological fields provided in an embodiment of this application.

[0028] Figure 7 A schematic block diagram of the terminal device provided in the embodiments of this application. Detailed Implementation

[0029] This application provides a method, system, device, and medium for invoking meteorological intelligent agents and scheduling tasks for continuous meteorological fields. To make the objectives, technical solutions, and effects of this application clearer and more explicit, the following detailed description, with reference to the accompanying drawings and embodiments, further illustrates this application. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0030] Those skilled in the art will understand that, unless specifically stated otherwise, the singular forms “a,” “an,” “the,” and “the” used herein may also include the plural forms. It should be further understood that the term “comprising” as used in this application means the presence of the stated features, integers, steps, operations, elements, and / or components, but does not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof. It should be understood that when we say an element is “connected” or “coupled” to another element, it can be directly connected or coupled to the other element, or there may be intermediate elements. Furthermore, “connected” or “coupled” as used herein can include wireless connections or wireless coupling. The term “and / or” as used herein includes all or any units and all combinations of one or more associated listed items.

[0031] It will be understood by those skilled in the art that, unless otherwise defined, all terms used herein (including technical and scientific terms) have the same meaning as commonly understood by one of ordinary skill in the art to which this application pertains. It should also be understood that terms such as those defined in general dictionaries should be understood to have the same meaning as in the context of the prior art, and should not be interpreted in an idealized or overly formal sense unless specifically defined as herein.

[0032] It should be understood that the sequence number and size of each step in this embodiment do not imply the order of execution. The execution order of each process is determined by its function and internal logic, and should not constitute any limitation on the implementation process of this application embodiment.

[0033] Research has shown that generative agents built upon large language models and multimodal models have demonstrated powerful capabilities in tasks such as information retrieval and code generation. However, existing agents can only process discrete, static symbolic information, and their supporting tool systems are built around text-based question answering, database querying, and code execution. When application scenarios expand to real-world physical scenarios with continuous spatial structures, strong spatiotemporal coupling, and dynamic evolutionary characteristics (such as meteorology, fluid mechanics, and climate prediction), generative agents cannot adapt to the task requirements of such scenarios due to the lack of native modeling capabilities and tool interfaces for high-dimensional, multivariable continuous spatiotemporal fields (such as temperature fields and wind fields). This makes it difficult for the predictive capabilities of existing generative agents to be reused for higher-level tasks.

[0034] To address the aforementioned issues, in this embodiment, a task instruction issued by a user in natural language is received, and the high-level task corresponding to the task instruction is decomposed into a chain of sub-tasks. Meteorological tools are selected from the meteorological tool center for each sub-task in the chain. An undirected task graph is generated based on the dependencies between the meteorological tools, with sub-tasks as nodes and dependencies as edges. The meteorological tools corresponding to each sub-task are executed according to the undirected task graph to obtain a continuous meteorological field. The continuous meteorological field is converted into a structured task risk semantic description, and a task strategy is generated based on the structured task risk semantic description. This application configures meteorological tools with native support for abstract interfaces and standardized descriptions of continuous meteorological fields. Through the abstract interface, continuous meteorological fields are natively supported as input and output objects. Meteorological tools are encapsulated as programmable tool nodes. Continuous field data flows between the tool and the execution engine, and the upper-layer agent is only responsible for business semantic parsing, enabling the agent to process continuous field data. Meanwhile, based on task requirements, meteorological tools are retrieved from the meteorological tool center that uses standardized descriptions as representations and arranged into a task undirected graph. Then, based on the task undirected graph, computing resources are called to execute the retrieved meteorological tools to obtain a continuous meteorological field, so that meteorological tools can be reused by upper-layer intelligent agents.

[0035] It should be noted that the executing entity of each embodiment of this application can be a computing service system with data processing, network communication, and program execution functions, such as an electronic system capable of realizing the above functions, a meteorological intelligent agent tool invocation and task scheduling system for continuous meteorological fields, etc. The following uses a meteorological intelligent agent tool invocation and task scheduling system for continuous meteorological fields (hereinafter referred to as "the system") as an example to describe the following embodiments.

[0036] The application content will be further explained below with reference to the accompanying drawings and the description of the embodiments.

[0037] This embodiment provides a method for invoking meteorological intelligent agent tools and orchestrating tasks for continuous meteorological fields, such as... Figure 1 and Figure 2 As shown, the method for invoking meteorological intelligent agents and orchestrating tasks for continuous meteorological fields specifically includes: S10. Receive task instructions issued by the user in natural language, and decompose the high-level task corresponding to the task instructions into a sub-task chain.

[0038] Specifically, mission instructions are in natural language form, such as voice, text, and written text, and contain mission requirements. Based on these instructions, the higher-level tasks that need to be performed can be determined. For example, if the mission instruction is to assess the flight risk in a certain area over the next 6 hours, then the higher-level task to be performed is flight risk assessment.

[0039] For example, a large language model or multimodal model can be used as the core controller of the intelligent agent. After receiving a task instruction, the core controller performs semantic parsing to extract structured task information. This structured task information may include key information such as task objectives, spatial scope, temporal scope, application domain, and key metrics. Then, the high-level task is decomposed into multiple logically independent and sequentially connected subtasks, forming a subtask chain. During the task decomposition of the high-level task, pre-set task decomposition rules or a large language model can be used.

[0040] For example, if the mission instruction is to assess the takeoff and landing risks of low-altitude aircraft in area XX over the next 24 hours, upon receiving the mission instruction, the agent is guided by a pre-set prompt template to perform a structured understanding of the instruction and obtain structured mission information. The prompt template can be: You are a weather task planning assistant. Please parse the user's task request into the following JSON format: { "task_type":"task objective", "target_region":"region name or latitude and longitude range", "time_horizon":"Time range (hours)", "domain": Application area (e.g., aviation, transportation, emergency response, etc.)", "key_concerns":["List of indicators to watch"] }

[0041] The core control layer of the intelligent agent can parse the task instructions using a large model (such as an LLM) to obtain: { "task_type":"risk assessment", "target_region":"XX region", "time_horizon":24, "domain":"low-altitude aviation", "key_concerns":["low-level wind shear","heavy precipitation","low visibility"] }

[0042] After obtaining the structured task information output by the large model, the structured task information is transmitted to the task planner of the agent. The task planner decomposes the task of assessing take-off and landing risks into a sub-task of obtaining meteorological background, a sub-task of predicting future state, a sub-task of extracting regional information, a sub-task of calculating risk indicators, and a sub-task of generating a report. This forms a sub-task chain of meteorological background -> predicting future state -> extracting regional information -> calculating risk indicators -> generating a report.

[0043] S20. Select meteorological tools for each subtask in the subtask chain from the meteorological tool center.

[0044] Specifically, the Meteorological Tool Center is a pre-built unified tool management layer used to collect meteorological tools from different sources and with different functions. It configures abstract interfaces and generates standardized descriptive metadata for each collected meteorological tool. Each meteorological tool in the Meteorological Tool Center is standardized into a tool unit that can be recognized, scheduled, and composed by intelligent agents. This solves the problem that generative agents cannot adapt to the task requirements of such scenarios due to the lack of native modeling capabilities and tool interfaces for high-dimensional, multi-variable continuous spatiotemporal fields (such as temperature fields and wind fields).

[0045] The abstract interface natively supports continuous weather fields, and the standardized description includes input space, output space, metadata, applicable conditions, quality metrics, and resource requirements. That is, each weather tool in the meteorological tool center inherits from the abstract interface and is represented using a standardized description, which can be expressed as: , in, Indicates a standardized description; Indicates the input space, Indicates the output space. and It can support NetCDF files, multidimensional tensors, JSON objects, etc. Meta-information can include variable types (temperature, wind speed, etc.), spatiotemporal resolution, prediction lead time, etc. Indicates applicable conditions, such as input data integrity requirements, regional scope, etc.; The quality measure can include output quality measures or uncertainties, such as RMSE (Root Mean Square Error), confidence intervals, etc. This indicates resource requirements, such as GPU / CPU requirements, video memory requirements, and estimated execution time.

[0046] It should be noted that, in order to facilitate the registration of meteorological tools to the meteorological tool center and the retrieval of meteorological tools registered in the meteorological tool center, the meteorological tool center can provide a registration interface, a query interface, and a dynamic loading interface. The registration interface supports registering meteorological tools to the meteorological tool center, the query interface supports retrieving meteorological tools from the meteorological tool center, and the dynamic loading interface is used to automatically register meteorological tools to the meteorological tool center.

[0047] For example: The registration interface is: register(tool_name:str,tool_class:Type[BaseTool],instance:BaseTool =None). It supports registering meteorological tool classes (instantiated each time they are called) or singleton instances (reusable). During registration, it automatically extracts standardized descriptions and stores them as indexes for meteorological tools. The query interface, query(constraints:dict)->List[BaseTool], supports fuzzy matching and precise filtering by tool name, input / output type, metadata conditions, resource requirements, etc., and returns a list of tools that meet the conditions for use by the task planner. The dynamic loading interface, load_from_path(module_path:str), supports scanning Python modules in a specified directory at runtime and automatically discovering and registering utility classes that inherit from the abstract interface.

[0048] In one embodiment, the registration process for meteorological tools to the meteorological tool center specifically includes: H10, Obtain the pre-built abstract interface; H20, The control meteorological model inherits the abstract interface and generates a standardized description for the meteorological model through the abstract interface; H30. Register meteorological tools to the Meteorological Tool Center based on standardized descriptions.

[0049] Specifically, the abstract interface is a predefined abstract base class `BaseTool`. All meteorological tools registered with the meteorological tool center inherit from this abstract interface, ensuring that all meteorological models registered with the meteorological tool center (such as meteorological loading models, AI forecast models, data interpolation tools, risk semantic mapping modules, etc.) expose a completely consistent calling format. This allows agents to call any meteorological model registered with the meteorological tool center. In this way, upper-layer agents (such as task planners) do not need to be aware of the internal implementation differences of meteorological models. They can interact with the standardized meteorological models (i.e., meteorological tools in the meteorological tool center) through the abstract interface, achieving plug-and-play and replaceability of meteorological models.

[0050] Furthermore, this abstract interface provides a calling interface for collecting standardized descriptions of meteorological models, through which standardized descriptions can be generated for the meteorological models. Specifically, this abstract interface can implement the following core methods: get_input_schema(): Returns the JSON schema definition of the input parameter, i.e., retrieves the input space; get_output_schema(): Returns the JSON schema definition of the output result, i.e., retrieves the output space and quality metrics; get_metadata(): Returns a dictionary of the tool's metadata, i.e., retrieves the metadata; get_resource_profile(): Returns a description of resource requirements, i.e., retrieves resource requirements; run(input:dict)->dict: The core execution logic of the tool, which enables the execution engine to directly run weather-related tools.

[0051] For example, the meteorological model is a short-term weather evolution prediction model, and its standardized description is achieved by rewriting the above method to achieve the content shown in Table 1.

[0052] Table 1

[0053] Note: U10 is the zonal wind (east-west direction) component at a height of 10 meters, V10 is the meridional wind (north-south direction) component at a height of 10 meters, TP is the cumulative precipitation, and T2M represents the air temperature at a height of 2 meters.

[0054] In one specific embodiment, the example code for registering a meteorological model to a meteorological tool center can be: #Instantiation Prediction Tool forecast_tool=WeatherForecastTool(model_path=" / path / to / model") #Register to Weather Tools Center registry=ToolRegistry.getInstance() registry.register("weather_forecast",forecast_tool) #Query Verification tools=registry.query({"metadata.spatial_res":"0.25°","resource.compute_type":"GPU"}).

[0055] Furthermore, in step S20 above, when selecting meteorological tools for sub-tasks from the meteorological tool center, precise matching, semantic matching, or a multi-candidate selection method can be used. Specifically, precise matching selects meteorological tools from the meteorological tool center based on their unique model identifiers (such as tool names); semantic matching selects tools based on the matching degree between task requirements and the metadata of the meteorological tools; and the multi-candidate selection method first selects several candidate meteorological tools based on semantic matching, and then selects the final meteorological tool from these candidates based on preset constraints. For example, in the example of low-altitude takeoff and landing risk assessment in the XX region above, for the sub-task of acquiring meteorological background, a meteorological data loading model capable of reading reanalysis data can be matched; for the sub-task of predicting future states, a meteorological forecast model with the corresponding resolution can be matched; for the sub-task of extracting regional information, a spatial range clipping tool can be matched; and for the sub-task of calculating risk indicators, a low-altitude flight risk quantification calculation model can be matched, thus completing the selection of meteorological tools for all sub-tasks in the sub-task chain.

[0056] In one embodiment, selecting meteorological tools from the meteorological tool center for each subtask in the subtask chain specifically includes: For each subtask in the subtask chain, obtain the task requirements of the subtask; Determine the similarity between the task requirements and the metadata of meteorological tools in the meteorological tool center; Based on the similarity, meteorological tools are selected from the meteorological tool center for each subtask.

[0057] Specifically, the task requirements of a subtask may include a functional description and the required set of meteorological variables. Spatial resolution Time interval Forecast timeliness The similarity score is based on the task requirements, including the applicable geographical area and input integrity status. Meta-information of various meteorological tools in the Meteorological Tool Center The semantic similarity between them is used as a basis for selecting meteorological tools. For example, the meteorological tool with the highest semantic similarity is selected as the meteorological tool (i.e., the execution model) for this sub-task, or several meteorological tools are selected as the meteorological tool set for this sub-task in order of high to low similarity.

[0058] In one embodiment, only meteorological tools are applicable. Meteorological tools can only be executed if certain conditions are met. Therefore, the process of selecting meteorological tools from the meteorological tool center for each subtask in the subtask chain can begin with applicable conditions. To select hard constraints and filter out applicable conditions Weather-related tools that cannot be fulfilled. Specifically, after obtaining the task requirements, the task requirements can be... Applicable conditions Compare, if the task requires Unable to meet the applicable conditions (i.e., the applicable conditions for meteorological tools) If the requirement cannot be met, then filter out the weather tool; if the task requires... Meets applicable conditions (i.e., the applicable conditions for meteorological tools) (If the requirements can be met), then calculate the task requirements. Meta-information of various meteorological tools in the Meteorological Tool Center Semantic similarity between them.

[0059] For example, for subtasks First, check the task requirements. Does it meet the applicable conditions for meteorological tools? If applicable conditions If the condition is not met, gating will apply. Set to 0 to filter this weather tool, if applicable. If satisfied, gating will apply. Set it to 1 to retain this weather tool. Then, calculate the task requirements. Meta-information of meteorological tools The similarity can be expressed as: , , in, Indicates task requirements Meta-information of meteorological tools similarity, Indicates task requirements Meta-information of meteorological tools The vector cosine similarity, This represents the consistency score for meteorological variables. Indicates the spatial resolution consistency score. This indicates the consistency score for temporal resolution. This indicates the score for consistency between forecast lead time and actual forecast. This represents the set of meteorological variables used in meteorological tools. All of these represent weighting coefficients.

[0060] For example: Suppose the task requirement of the subtask is "weather forecast for the next 24 hours". ={U10,V10,TP}、 ≤0.25° ≤1 hour For a period of ≥24 hours, and provided the initial field already exists, U10 represents the zonal wind (east-west direction) component at a height of 10 meters, V10 represents the meridional wind (north-south direction) component at a height of 10 meters, and TP represents cumulative precipitation. (Meteorological tools) Meta information For: Function description "Global Short-Term Rapid Forecast", ={T2M,U10,V10,TP}, spatial resolution 0.25°, temporal resolution 1 hour, maximum duration 72 hours; applicable conditions For "requires field initialization, valid globally," T2M represents the air temperature at a height of 2 meters. (Meteorological tools) Applicable conditions To provide real-time radar data as needed.

[0061] For meteorological tools Since the subtask initializes the field, meteorological tools Applicable conditions For meteorological tools that require initialization of fields and are valid globally and regionally. Applicable conditions To be satisfied Then, based on task requirements and metadata... Sure =0.92, =0.75, , and If both are 1, then the metadata of the subtask and meteorological tool A is... similarity =0.40×0.92+0.25×0.75+0.15+0.10+0.10=0.9055. (For meteorological tools) Due to applicable conditions Unable to be satisfied, therefore These are directly filtered out. Therefore, meteorological tools... Weather tools are a subtask.

[0062] In one embodiment, selecting meteorological tools from the meteorological tool center for each sub-task based on the similarity specifically includes: Several candidate meteorological tools are selected from the meteorological tool center in descending order of similarity. Meteorological tools are selected from several candidate meteorological tools based on task priority and current system resource status.

[0063] Specifically, the current system resource status serves as a hard constraint to eliminate infeasible candidate meteorological tools whose resource requirements cannot be met, while task priority determines the scoring weight of the comprehensive score for candidate meteorological tools. The comprehensive score serves as the selection criterion for meteorological tools, and the influencing indicators for determining the comprehensive score may include one or more of the following: quality metrics, estimated execution time, and target resource pool load.

[0064] It is understandable that when selecting meteorological tools from several candidate meteorological tools based on task priority and current system resource status, the current system resource status can be used as a hard constraint to remove infeasible candidate meteorological tools whose resource requirements cannot be met. Then, the task priority can be used to obtain the scoring weight, and the comprehensive score can be calculated using the scoring weight and impact indicators. Finally, the meteorological tool corresponding to the subtask can be selected from the feasible candidate meteorological tools based on the comprehensive score.

[0065] In one embodiment, the overall score can be expressed as: , in, This represents the overall score. This represents the normalized quality measure. Indicates the estimated execution time. Indicates the maximum estimated execution time. This indicates the load of the target resource pool (i.e., video memory). All of these represent the scoring weights.

[0066] It should be noted that in practical applications, quality metrics and expected execution time can be used as influencing indicators, as can the quality metrics and target resource pool load, as well as the expected execution time and target resource pool load. Alternatively, other influencing indicators can be added according to actual needs. No specific restrictions are imposed here.

[0067] Furthermore, task priority reflects the task execution mode of the subtask, which includes speed mode and accuracy mode. Correspondingly, task priorities include speed priority and accuracy priority. A first set of scoring weights can be pre-configured for speed priority and a second set of scoring weights can be configured for accuracy priority. When the task priority is speed priority, the first set of scoring weights is used as the scoring weight; when the task priority is accuracy priority, the second set of scoring weights is used as the scoring weight. Therefore, when determining the scoring weight, the task execution mode of the subtask can be obtained first, then the task priority can be determined based on this task execution model, and finally the scoring weight can be selected based on the task priority.

[0068] In addition, in practical applications, before determining the comprehensive score, it is also necessary to check whether the impact indicators meet the impact indicator constraints corresponding to the sub-task. Feasible candidate meteorological tools that cannot meet the impact indicator constraints are directly filtered out, and only the comprehensive scores of feasible candidate meteorological tools that meet the impact indicator constraints are calculated, so as to improve the success rate of sub-task execution.

[0069] Examples: Feasible candidate meteorological tools The normalized quality metric is 0.84, the estimated execution time is 12 seconds, the target resource pool load is 8GB, and it is a feasible candidate meteorological tool. The normalized quality metric is 0.95, the estimated execution time is 40 seconds, and the target resource pool load is 24GB.

[0070] If the execution time constraint for the subtask is 20 seconds, feasible candidate meteorological tools are... The task was eliminated because its estimated execution time exceeded the execution time constraint; if the subtask's execution time constraint is 90 seconds and the target resource pool load constraint is 16GB, then weather tools are a feasible candidate. The task was removed because the target resource pool load was insufficient. If the subtask's execution time constraint is 90 seconds, the target resource pool load constraint is 32GB, and the task execution mode is precision mode, then the task priority is precision first. A comprehensive score is calculated using the second scoring weight set corresponding to precision first, and this comprehensive score is used to select feasible candidate meteorological tools. and feasible candidate meteorological tools Meteorological tools were selected as subtask execution models.

[0071] S30. Generate an undirected graph of the task based on the dependencies between meteorological tools.

[0072] Specifically, the nodes of the undirected graph represent subtasks, and the edges represent the dependencies between meteorological tools corresponding to the subtasks. These dependencies include data dependencies, control dependencies, and semantic dependencies. Data dependencies refer to the output data of upstream meteorological tools being used as input data for downstream meteorological tools; control dependencies refer to the fact that the startup of downstream meteorological tools depends on the execution result of upstream meteorological tools; and semantic dependencies refer to the use of semantic information extracted by upstream meteorological tools by downstream meteorological tools. For example, ... Figure 3 As shown, in the undirected graph of the task, two nodes can have one or more of the following dependencies: data dependency, control dependency, and semantic dependency. When one of these dependencies exists between two nodes, an edge is created between them, and the dependency is recorded on the edge. When multiple dependencies exist between two nodes, the topological in-degree is not increased repeatedly; instead, all dependencies are recorded on the same directed edge. For example, when two nodes have both data dependency and control dependency, an edge is created between them, and both the data dependency and control dependency are recorded on this edge.

[0073] In one embodiment, generating the task undirected graph based on the dependencies between meteorological tools specifically includes: In accordance with the task order of the subtasks, the output descriptions of meteorological tools are matched with the input descriptions of downstream meteorological tools that are not bound to output descriptions in order to build data dependency edges between meteorological tools corresponding to the subtasks. Construct semantic dependency edges between meteorological tools and downstream meteorological tools that inherit their semantic results; Construct control dependency edges between meteorological tools and downstream meteorological tools that are triggered by them; An undirected graph of the task is generated based on the data dependency edges, semantic dependency edges, and control dependency edges.

[0074] Specifically, after selecting a meteorological tool for each subtask, the subtask chain can be converted into a set of tool nodes. , Both represent tool nodes. This indicates the number of tool nodes. Each tool node records its input slots, execution preconditions, and output description. Furthermore, for each input and output item in each tool node within the tool node set, a standard output description and a standard input description are constructed. The standard output description and standard input description include the same information items, which can include one or more of the following: identifier name, data type, tensor / array dimension structure shape, physical unit unit, spatial reference (spatial_ref), valid time range (time_range), and semantic tag (semantic_tag).

[0075] After constructing standard output and standard input descriptions for each tool node, the output descriptions of meteorological tools are matched with the input descriptions of downstream meteorological tools that do not have bound output descriptions, according to the task order of the subtasks. When the compatibility match is satisfied, a data dependency edge is established between the meteorological tool and the downstream meteorological tool, and the parameter binding relationship is recorded. , Indicates the first downstream meteorological tool One input item, The first of the meteorological tools There are several input items. If there are only incompatible items that can be matched after conversion using a conversion tool, a conversion tool (such as a unit conversion tool, regrinding tool, or format conversion node tool) can be inserted between the meteorological tool and the downstream meteorological tool. Then, data dependency edges can be built between the meteorological tool and the conversion tool, and between the conversion tool and the downstream meteorological tool. If there are incompatible items that cannot be converted, no data dependency edges should be established between the meteorological tool and the downstream meteorological tool. In addition, it should be noted that when multiple upstream meteorological tool output items match the same downstream meteorological tool input item, an input item can be randomly selected, or the input item with the highest matching score can be selected. Furthermore, when a meteorological tool requires multiple input items, data dependency edges can be established for each input slot of the meteorological tool.

[0076] After the data dependency edges are constructed, it is checked whether there is a control relationship between the meteorological tools. That is, it is checked whether one of the two meteorological tools requires the other meteorological tool to meet the preset guard conditions (such as execution success, execution failure, or other constraints) before it can be started. If there is a control relationship between the two meteorological tools, a control dependency edge is constructed between the two meteorological tools.

[0077] After constructing control dependency edges, it is necessary to detect whether there is a semantic inheritance relationship between meteorological tools, that is, to detect whether downstream meteorological tools need to inherit the semantic results of upstream meteorological tools (such as physical meaning, variable name, unit, coordinate range, effective time or risk ontology label, etc.). If there is a semantic inheritance relationship between meteorological tools, then semantic dependency edges are constructed between meteorological tools.

[0078] It should be noted that during the construction of data dependency edges, control dependency edges, and semantic dependency edges, a cycle-agnostic verification is also performed. This cycle-agnostic verification process can be performed for each additional edge... Check if the edges already exist in the currently constructed undirected task graph. arrive A reachable path; if it exists arrive If a path to the loop is not found, it means the newly constructed edge will form a cycle. The planner can eliminate the cycle by adjusting the subtask phase, selecting other upstream nodes, or expanding the loop into the next iteration node. and Each of these represents a node in the undirected graph of the task.

[0079] Furthermore, during the process of executing the meteorological tools corresponding to each subtask according to the aforementioned undirected task graph to obtain a continuous meteorological field, the undirected task graph is dynamically adjusted. This dynamic adjustment process involves updating the undirected task graph dynamically after each task node is completed, based on the node's running state, the task conditions of the corresponding meteorological tool, quality metrics, and resource requirements. This dynamic update includes one or more of the following: adding task nodes, deleting task nodes, redirecting data edges, and selecting branch paths. For example, ... Figure 3 and Figure 4 As shown, the data integrity check node outputs missing_ratio; when missing_ratio > When the (preset threshold) is reached, the "data interpolation" node is inserted between the data loading node and the prediction node, and the original data edges are redirected to "data loading → data interpolation → prediction"; when missing_ratio ≤ When the results of upstream meteorological tools are supplied to multiple downstream meteorological tools, a one-to-many data edge is established, allowing for the parallel activation of each downstream meteorological tool. For example, a regional forecast field can simultaneously enter three nodes: "wind shear calculation," "precipitation intensity calculation," and "visibility estimation." After all three nodes are completed, the risk indicators are merged by the convergence node.

[0080] S40. Execute the meteorological tools corresponding to each subtask according to the undirected graph of the task to obtain a continuous meteorological field.

[0081] Specifically, the workflow scheduling engine reads the topology of the undirected task graph, determines the set of executable nodes based on the dependencies between nodes, and schedules the corresponding meteorological tool to start execution on the computing resources when the executable node meets the execution preconditions. After each task node finishes execution, the computing resources occupied by the node are automatically released, and all its outgoing edges are traversed to update the in-degree state of downstream nodes. Downstream nodes that meet the execution conditions are added to the set of executable nodes until all task nodes have finished execution. Finally, the output results of all nodes are spliced ​​together to obtain a complete and continuous meteorological field.

[0082] In one embodiment, executing the meteorological tools corresponding to each subtask according to the undirected task graph to obtain a continuous meteorological field specifically includes: For each task node in the undirected task graph, the initial in-degree of the task node is determined based on the upstream task node with which it has an edge. The task nodes with an initial in-degree of 0 and whose guard conditions are activated are added to the preparation set, wherein the task nodes in the preparation set are executed in parallel and / or in serial manner. Execute the meteorological tools corresponding to the task nodes in the preparation set, and decrement the initial in-degree of the downstream task nodes that have an edge with the task node by 1 after each task node is executed. Re-execute the process by adding the task nodes with an initial in-degree of 0 and activated guard conditions to the preparation set until all task nodes have been executed.

[0083] Specifically, the execution engine calculates the number of distinct predecessor nodes (i.e., the number of upstream task nodes with edges to the task node) of each node in the undirected graph of the task as the initial in-degree, and adds all nodes with an initial in-degree of 0 and whose guard conditions are activated to the preparation set. Then, for each node taken from the preparation set for execution, its outgoing edges are deleted, the initial in-degree of the node corresponding to that outgoing edge is decremented by 1, and newly appearing nodes with an initial in-degree of 0 are added to the preparation set. Nodes in the preparation set can be executed in parallel; for example, while performing the prediction for the first time step, the preprocessing of the input data for the second time step can begin simultaneously. When resources are insufficient and sequential execution is necessary, nodes can be selected for priority based on conditions such as higher task priority, earlier deadline, availability of required resources, or smaller node ID to ensure repeatable results, while nodes without dependencies can be executed in parallel.

[0084] For example, consider a node set V = {A, B, C, D} and an edge set E = {(A, C), (B, C), (B, D), (C, D)}. The initial in-degrees are indegree(A) = 0, indegree(B) = 0, indegree(C) = 2, and indegree(D) = 2. Therefore, the first scheduling layer is {A, B}, and A and B can be executed in parallel. After both are completed, the initial in-degree of C becomes 0, and the second layer executes {C}; after C is completed, the initial in-degree of D becomes 0, and the third layer executes {D}. The hierarchical topology order is {A, B} → {C} → {D}. If the system can only run serially and A and B have the same priority, A → B → C → D can be obtained by node ID; B → A → C → D is also a valid topology order. If B has a higher priority than A, then B → A → C → D is chosen. For the same pair of nodes with multiple dependencies, the initial in-degree is counted only once for the "upstream node"; however, before the downstream node enters the ready state, the data dependency, control dependency, and semantic dependency of that edge must still be checked simultaneously. For mutually exclusive branches, only the edges in the activated branch participate in this topology sorting, and the inactive branches are marked as Skipped.

[0085] Furthermore, when executing the meteorological tools corresponding to each subtask according to the aforementioned undirected task graph, the execution engine distributes the subtasks to the corresponding computing resource pools (such as GPU pools, CPU pools, etc.) based on the resource requirements of the meteorological tools. For example, if the resource requirement of the meteorological tool DataLoader is I / O intensive, it is distributed to the CPU pool; if the resource requirement of the meteorological tool WeatherForecast is computationally intensive, it is distributed to the GPU pool. In addition, the execution engine maintains a state machine for each node and records the start time, end time, actual resource consumption, storage location of output data, and verification information. This facilitates rapid location of problematic nodes in case of subsequent anomalies and provides traceable runtime data for subsequent model optimization.

[0086] It should be noted that when a node fails to execute (such as the WeatherForecast tool failing due to insufficient video memory), the planner can trigger a rollback mechanism to attempt to use alternative tools (such as switching to "fast mode") and retry after reducing the resolution; if this fails, a failure report and the reason are returned to the upper layer. The alternative tools can be determined using the same selection method as the weather tools described above, or a set of alternative tools can be built when selecting weather tools, and then directly selected from this set when needed.

[0087] In one embodiment, during the process of executing meteorological tools corresponding to each subtask according to the undirected task graph to obtain a continuous meteorological field, the method further includes: The generation quality of the continuous meteorological field is checked to see if it meets the requirements. If the requirements are met, the continuous weather field will be output. If the requirements are not met, an iterative task node is generated, and the meteorological tools corresponding to each subtask are re-executed according to the undirected task graph by executing the iterative task node.

[0088] Specifically, the obtained complete continuous meteorological field is compared with the preset quality verification standards. The verification content includes the reasonable range of meteorological element values, spatial interpolation smoothness, missing data ratio, and physical consistency of meteorological elements. If all verification items meet the requirements, the continuous meteorological field is deemed to be of qualified quality and is directly output. If there are verification items that do not meet the requirements, an iterative task node is generated, the task undirected graph is updated, and each subtask is re-executed. Based on the verification results, relevant parameters can be adjusted, such as adjusting the interpolation algorithm and modifying the resolution parameters, until the regenerated continuous meteorological field meets the quality requirements and is output.

[0089] In one embodiment, in order to enable the execution engine to support different hardware platforms (such as GPU platforms, NPU platforms, etc.), the execution engine abstracts computing resources into a unified resource pool interface, and the resource types supported by the resource pool interface are shown in Table 2.

[0090] Table 2

[0091] Each weather-related tool, during registration, clearly indicates its support for different computing platforms based on its resource requirements, for example: { "tool_name":"WeatherForecast", "resource_profiles":[ {"platform":"Hardware1","min_memory":"16GB","backend":"torch_cuda"}, {"platform":"Hardware2","min_memory":"32GB","backend":"torch_npu"} ] }

[0092] Furthermore, when the execution engine schedules a weather-related tool, the adaptive selection process includes: Obtain available resources: Query the available nodes and remaining resources of each resource pool in the current system; Filter candidate hardware platforms: Filter out the hardware platforms supported by the current environment; Matching decision: If the user specifies a platform preference (such as "Platform A"), then the platform is selected according to the preference; otherwise, the optimal available hardware platform is selected from the hardware platforms supported by the current environment based on the task priority marked by the tool and the current resource load. Backend adaptation: The execution engine dynamically loads the corresponding backend implementation based on the selected hardware platform to execute meteorological tools without modifying the business code of the meteorological tools.

[0093] For example, taking WeatherForecastTool as an example, its internal implementation achieves platform adaptation through conditional judgment or factory pattern: class WeatherForecastTool(BaseTool): def_init_(self,model_path,platform="auto"): self.platform=platform or self._detect_platform() self.model=self._load_model(model_path) def_detect_platform(self): if torch.cuda.is_available(): return "CUDA" elif torch.npu.is_available(): return "CANN" else: return "CPU" def_load_model(self, path): if self.platform=="CUDA": return torch.load(path, map_location="cuda") elif self.platform=="CANN": return torch.load(path,map_location="npu") else: return torch.load(path,map_location="cpu") def run(self, input_data): # The business logic is completely consistent, and the underlying tensor operations are automatically adapted by PyTorch. tensor_input=self._to_tensor(input_data) output=self.model(tensor_input) return self._to_output(output).

[0094] In addition, in practical applications, the consistency and reliability of the system can be verified on both platforms, and the verification methods are shown in Table 3.

[0095] Table 3

[0096] S50. Convert the continuous meteorological field into a structured task risk semantic description, and generate a task strategy based on the structured task risk semantic description.

[0097] Specifically, a pluggable semantic mapping module is pre-built and registered with the meteorological tool center as a meteorological tool. After obtaining a continuous meteorological field, the semantic mapping module can be directly retrieved from the meteorological tool center. This semantic mapping module is used to transform the high-dimensional continuous meteorological field (numerical) into a structured task risk semantic description that the agent can reason about, so that the agent can generate task strategies based on the structured task risk semantic description.

[0098] In one embodiment, converting the continuous meteorological field into a structured task risk semantic description and generating a task strategy based on the structured task risk semantic description specifically includes: Extract the continuous task indicators from the continuous meteorological field and discretize the continuous task indicators into gridded task indicators; Spatiotemporal positioning is performed based on gridded task indicators to identify risk areas, and the risk level and confidence level of the risk areas are obtained. A structured semantic description of task risk is generated based on the risk area, risk level, and confidence level. The structured task risk semantic description is input into a large model, and the large model generates task strategies.

[0099] Specifically, mission continuity indicators refer to mission-related characteristic indicators in continuous meteorological fields (such as temperature field, humidity field, wind speed field, precipitation field, etc.). For example, as shown in Table 4, horizontal wind shear is extracted from the 10-meter wind field (U10, V10), precipitation intensity is extracted from the cumulative precipitation TP, and the perceived temperature or condensation height is calculated from the temperature field and humidity field.

[0100] Table 4

[0101] Next, as Figure 5 As shown, the continuous task indicators are discretized into gridded task indicators, and the risk level of each grid is determined using the gridded task indicators. Finally, the risk area is determined using the risk level of each grid, the risk level of the risk area, and the confidence level, etc., to form a structured semantic description of task risk.

[0102] In discretizing the continuous task indicators into gridded task indicators, the continuous indicators can be spatially discretized according to the geographic grid of the target area. Each grid cell stores the statistical values ​​(such as average, maximum, or center point values) of the continuous task indicators within that area, facilitating subsequent batch risk assessment. The discretized gridded task indicators also retain the spatial coordinate information of the corresponding grid to support the accurate location of subsequent risk areas. Then, a risk rule engine or lightweight classification model is used to determine the risk level corresponding to the gridded task indicators. For example, as shown in Table 5, if the precipitation intensity is between 10-20 mm / h, then the risk of heavy precipitation = "high"; if the horizontal wind shear is >8 m / s / km, then the risk of low-level wind shear = "extremely high"; and if the visibility is <0.5 km, then the risk of low visibility = "extremely high".

[0103] Table 5

[0104] A risk region is a connected set of all grid cells that meet the target risk level requirements. After performing connectivity clustering on discrete grids, multiple disconnected risk regions can be obtained. Each risk region records its own latitude and longitude range, the number of grid cells it covers, the highest risk level within the region, and the average confidence level. By organizing the location information, risk level information, and confidence level information of the risk regions according to a preset structure, a complete structured task risk semantic description can be generated. After inputting this structured task risk semantic description into a trained large model, the large model will combine the user's preset task background and convert the structured task risk semantic description into a natural language task strategy that conforms to human reading habits. For example, for flight missions, it may provide "There is a moderate wind shear risk in the XX airspace; it is recommended to adjust the flight route to the XX area to avoid it," or for outdoor activity protection, it may provide "There is a high level of heavy precipitation risk in the XX scenic area in the next three hours; it is recommended to notify tourists to evacuate to a safe area as soon as possible." This completes the closed loop from raw meteorological data to directly executable task decisions.

[0105] The semantic description of structured task risks can be in JSON format, which can be: { "region":"XX region", "time_window":{ "start":"2024-05-23T12:00:00Z", "end":"2024-05-24T12:00:00Z" }, "risks":[ { "type":"low_level_wind_shear (low-level wind shear)", "level":"HIGH" "confidence":0.85, "peak_time":"2024-05-23T15:00:00Z", "affected_area":"A 5km radius around the XX building", "description": "The wind shear intensity in the XX area is expected to exceed 5 m / s / km around 3 PM, which may affect takeoff and landing safety." }, { "type":"heavy_precipitation (precipitation intensity)", "level":"MODERATE (Medium)", "confidence":0.70, "peak_time":"2024-05-24T02:00:00Z", "intensity":"12mm / h", "description": "Moderate rainfall is expected in the early morning hours; caution should be taken to avoid slipping during ground operations." } ], "overall_assessment": "The main risk in the next 24 hours is low-level wind shear in the afternoon; it is recommended to suspend takeoffs and landings during this period. The risk of precipitation in the early morning is manageable, but ground personnel should be reminded to take precautions." "disclaimer": "This forecast is based on meteorological model output and is subject to uncertainty. Please make a final decision based on real-time observations."

[0106] } For example: Let A be a 1km × 1km task grid within the area Ω surrounding XX airport, converted by the region clipping and remeshing tool. The accumulated precipitation at 14:00 and 15:00 is 7.0 mm and 20.0 mm respectively. Then, the hourly precipitation intensity at 15:00 is... (15:00)=TP(15:00) TP(14:00) = 13.0 mm / h. Calculate the one-hour precipitation intensity for all grids within Ω and generate a mask. Connectivity analysis is performed on adjacent grids exceeding the preset precipitation intensity threshold to obtain the boundaries and areas of the affected risk areas. For example, if 19 adjacent grids exceed the preset precipitation intensity threshold, the risk area is denoted as "approximately 19 km² area around XX Airport". Based on "10 mm / h < The rule "≤20mm / h corresponds to high risk" determines the risk level as "high". If 17 out of 20 ensemble forecast members reach this preset precipitation intensity threshold, and the mass metric meets the preset mass threshold, the confidence level can be calculated as 17 / 20 = 0.85. Finally, the precipitation intensity, rule number, region, time, and confidence level are written into JSON to form a structured task risk semantic description. This structured task risk semantic description can be: { "source_field":"A", "risk_type":"heavy_precipitation (precipitation intensity)", "level":"HIGH" "affected_area":{ "name":"Surrounding XX Airport", "area_km2":19, "geometry": "Generated from the connected component boundaries of B(t,x,y)" }, "confidence":0.85, "time_window":{ "start":"2024-05-23T15:00:00+08:00", "end":"2024-05-23T16:00:00+08:00" }, "evidence":{ "formula":"TP(15:00)-TP(14:00)", "value":13.0, "unit":"mm / h", "threshold_rule":"10< <=20=>HIGH" }, "explanation": "The hourly precipitation intensity in the region reached 13.0 mm / h, exceeding the high-risk threshold of 10 mm / h." } Similarly, the semantic extraction process for low-level wind shear and low visibility is the same as the above process: calculate the wind shear index and visibility index from A respectively, form a super-threshold spatiotemporal mask, locate the connected region, map the risk level according to the rules, and calculate the confidence level by combining the quality metric or the set member consistency rate.

[0107] Furthermore, after obtaining the structured task risk semantic description, this description is reported to the agent core controller (such as a large model). The agent core controller then injects the structured task risk semantic description as part of the system prompts into the LLM context. These prompts guide the agent core controller to output the task strategy in natural language, rather than simply listing data. For example, the task strategy can explicitly propose action suggestions and highlight the most critical risk points.

[0108] For example, the task strategy could be: "According to meteorological model forecasts, there is a high-risk low-level wind shear in the XX area from 3 pm to 6 pm tomorrow, which may affect the safety of eVTOL flights. It is recommended to suspend take-off and landing operations during this period. Although there is moderate precipitation in the early morning, it will mainly affect ground activities, and the risk of aerial operations is controllable. Please note that there is uncertainty in meteorological forecasts, and it is recommended to make dynamic adjustments based on real-time radar observations."

[0109] In summary, this application's embodiments pre-construct a meteorological tool center, registering complex scientific computing models to this center to encapsulate them into standardized meteorological tools. Upon receiving a task instruction from natural language, the core controller of the intelligent agent (such as a large language model or a multimodal model) parses the instruction to convert it into a sub-task chain. Then, it calls a task planner to invoke and orchestrate meteorological tools based on the sub-task chain, forming an undirected task graph. The execution engine then executes the meteorological tools according to this undirected task graph to obtain a continuous meteorological field. Finally, it calls a semantic mapping module to convert the continuous meteorological field into a structured task risk semantic description and generates a task strategy based on this description. This allows continuous field data to flow between the meteorological tools and the execution engine, while the upper-layer intelligent agent is only responsible for business semantic parsing. This enables the agent to process continuous field data and allows meteorological tools to be reused by the upper-layer intelligent agent.

[0110] In addition, the system records the execution time, resource consumption, and output quality of each meteorological tool each time a task is executed. This data is used to analyze task bottlenecks offline, optimize the tool selection strategy of the task planner (e.g., reinforcement learning), and update the statistical information of the tools for reference in subsequent tasks.

[0111] Based on the above-mentioned method for invoking and scheduling meteorological intelligent agent tools for continuous meteorological fields, this embodiment provides a system for invoking and scheduling meteorological intelligent agent tools for continuous meteorological fields, such as... Figure 6 As shown, the system includes: The core control layer 100 of the intelligent agent is used to receive task instructions issued by the user in natural language and decompose the high-level task corresponding to the task instruction into a sub-task chain. The task planning and orchestration layer 200 is used to select meteorological tools from the meteorological tool center for each subtask in the subtask chain, and generate an undirected task graph based on the dependency relationship between meteorological tools. The execution engine 300 is used to execute the meteorological tools corresponding to each subtask according to the undirected graph of the task to obtain a continuous meteorological field. The risk semantic mapping and interaction layer 400 is used to convert the continuous meteorological field into a structured task risk semantic description and generate a task strategy based on the structured task risk semantic description.

[0112] Based on the above-described method for invoking and scheduling meteorological intelligent agent tools for continuous meteorological fields, this embodiment provides a computer-readable storage medium storing one or more programs that can be executed by one or more processors to implement the steps in the method for invoking and scheduling meteorological intelligent agent tools for continuous meteorological fields as described in the above embodiment.

[0113] Based on the aforementioned method for invoking meteorological intelligent agents and scheduling tasks for continuous meteorological fields, this application also provides a terminal device, such as... Figure 7 As shown, it includes at least one processor 20; a display screen 21; and a memory 22, and may also include a communications interface 23 and a bus 24. The processor 20, display screen 21, memory 22, and communications interface 23 can communicate with each other via the bus 24. The display screen 21 is configured to display a preset user guide interface in the initial setup mode. The communications interface 23 can transmit information. The processor 20 can invoke logical instructions in the memory 22 to execute the methods described in the above embodiments.

[0114] Furthermore, the logical instructions in the aforementioned memory 22 can be implemented as software functional units and, when sold or used as independent products, can be stored in a computer-readable storage medium.

[0115] The memory 22, as a computer-readable storage medium, can be configured to store software programs, computer-executable programs, such as program instructions or modules corresponding to the methods in the embodiments of this disclosure. The processor 20 executes functional applications and data processing by running the software programs, instructions, or modules stored in the memory 22, thereby implementing the methods in the above embodiments.

[0116] The memory 22 may include a program storage area and a data storage area. The program storage area may store the operating system and application programs required for at least one function; the data storage area may store data created based on the use of the terminal device. Furthermore, the memory 22 may include high-speed random access memory (RAM) and non-volatile memory. Examples include various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks, as well as transient storage media.

[0117] Furthermore, the specific process of loading and executing multiple instruction processors in the aforementioned storage medium and terminal device has been described in detail in the above method, and will not be repeated here.

[0118] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application.

Claims

1. A method for invoking meteorological intelligent agents and scheduling tasks for continuous meteorological fields, characterized in that, The method includes: Receive task instructions from users in natural language and decompose the high-level tasks corresponding to the task instructions into sub-task chains; Meteorological tools are selected from the meteorological tool center for each subtask in the subtask chain. The meteorological tools in the meteorological tool center inherit the native abstract interface that supports continuous meteorological fields and are configured with standardized descriptions. The standardized descriptions include input space, output space, meta-information, applicable conditions, quality metrics, and resource requirements. Generate an undirected graph of the task based on the dependencies between meteorological tools; Execute the meteorological tools corresponding to each subtask according to the undirected graph of the task to obtain a continuous meteorological field; The continuous meteorological field is converted into a structured task risk semantic description, and a task strategy is generated based on the structured task risk semantic description.

2. The method for invoking meteorological intelligent agents and scheduling tasks for continuous meteorological fields according to claim 1, characterized in that, The registration process for the aforementioned meteorological tools specifically includes: Obtain a pre-built abstract interface that supports continuous weather fields as input / output objects; The meteorological model is controlled to inherit the abstract interface, and a standardized description is generated for the meteorological model through the abstract interface. Based on the standardized description, the meteorological model is registered with the meteorological tool center.

3. The method for invoking meteorological intelligent agents and scheduling tasks for continuous meteorological fields according to claim 1 or 2, characterized in that, The step of selecting meteorological tools from the meteorological tool center for each subtask in the subtask chain specifically includes: For each subtask in the subtask chain, obtain the task requirements of the subtask; Determine the similarity between the task requirements and the metadata of meteorological tools in the meteorological tool center; Based on the similarity, meteorological tools are selected from the meteorological tool center for each subtask.

4. The method for invoking meteorological intelligent agents and scheduling tasks for continuous meteorological fields according to claim 3, characterized in that, The specific steps of selecting meteorological tools from the meteorological tool center for each sub-task based on the similarity include: Several candidate meteorological tools are selected from the meteorological tool center in descending order of similarity. Meteorological tools are selected from several candidate meteorological tools based on task priority and current system resource status.

5. The method for invoking meteorological intelligent agents and scheduling tasks for continuous meteorological fields according to claim 1, characterized in that, The process of generating an undirected graph based on the dependencies between meteorological tools specifically includes: In accordance with the task order of the subtasks, the output descriptions of meteorological tools are matched with the input descriptions of downstream meteorological tools that are not bound to output descriptions in order to build data dependency edges between meteorological tools corresponding to the subtasks. Construct semantic dependency edges between meteorological tools and downstream meteorological tools that inherit their semantic results; Construct control dependency edges between meteorological tools and downstream meteorological tools that are triggered by them; An undirected graph of the task is generated based on the data dependency edges, semantic dependency edges, and control dependency edges.

6. The method for invoking meteorological intelligent agents and scheduling tasks for continuous meteorological fields according to claim 1, characterized in that, The step of executing the meteorological tools corresponding to each subtask according to the undirected graph of the task to obtain a continuous meteorological field specifically includes: For each task node in the undirected task graph, the initial in-degree of the task node is determined based on the upstream task node with which it has an edge. The task nodes with an initial in-degree of 0 and whose guard conditions are activated are added to the preparation set, wherein the task nodes in the preparation set are executed in parallel and / or in serial manner. Execute the meteorological tools corresponding to the task nodes in the preparation set, and decrement the initial in-degree of the downstream task nodes that have an edge with the task node by 1 after each task node is executed. Re-execute the process by adding the task nodes with an initial in-degree of 0 and activated guard conditions to the preparation set until all task nodes have been executed.

7. The method for invoking meteorological intelligent agents and scheduling tasks for continuous meteorological fields according to claim 1 or 6, characterized in that, In the process of executing the meteorological tools corresponding to each subtask according to the undirected graph of the task to obtain a continuous meteorological field, the method further includes: The generation quality of the continuous meteorological field is checked to see if it meets the requirements. If the requirements are met, the continuous weather field will be output. If the requirements are not met, an iterative task node is generated, and the meteorological tools corresponding to each subtask are re-executed according to the undirected task graph by executing the iterative task node.

8. The method for invoking meteorological intelligent agent tools and scheduling tasks for continuous meteorological fields according to claim 1 or 6, characterized in that, In the process of executing the meteorological tools corresponding to each subtask according to the undirected graph of the task to obtain a continuous meteorological field, the method further includes: After each task node in the undirected task graph is completed, the undirected task graph is dynamically updated based on the node's running status, the task conditions of the meteorological tool corresponding to the task node, the quality metric, and the required resources. The dynamic update includes one or more of the following: adding task nodes, deleting task nodes, redirecting data edges, and selecting branch paths.

9. The method for invoking meteorological intelligent agents and scheduling tasks for continuous meteorological fields according to claim 1, characterized in that, The step of converting the continuous meteorological field into a structured task risk semantic description and generating a task strategy based on the structured task risk semantic description specifically includes: Extract the continuous task indicators from the continuous meteorological field and discretize the continuous task indicators into gridded task indicators; Spatiotemporal positioning is performed based on gridded task indicators to identify risk areas, and the risk level and confidence level of the risk areas are obtained. A structured semantic description of task risk is generated based on the risk area, risk level, and confidence level. The structured task risk semantic description is input into a large model, and the large model generates task strategies.

10. A meteorological intelligent agent tool invocation and task scheduling system for continuous meteorological fields, characterized in that, The system includes: The core control layer of the intelligent agent is used to receive task instructions issued by the user in natural language and decompose the high-level task corresponding to the task instruction into a chain of sub-tasks. The task planning and orchestration layer is used to select meteorological tools from the meteorological tool center for each subtask in the subtask chain, and generate an undirected task graph based on the dependencies between meteorological tools. An execution engine is used to execute meteorological tools corresponding to each subtask according to the undirected graph of the task to obtain a continuous meteorological field. The risk semantic mapping and interaction layer is used to convert the continuous meteorological field into a structured task risk semantic description and generate a task strategy based on the structured task risk semantic description.

11. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores one or more programs, which can be executed by one or more processors to implement the steps in the meteorological intelligent agent tool invocation and task orchestration method for continuous meteorological fields as described in any one of claims 1-9.

12. A terminal device, characterized in that, include: Processor and memory; The memory stores a computer-readable program that can be executed by the processor; When the processor executes the computer-readable program, it implements the steps in the meteorological intelligent agent tool invocation and task orchestration method for continuous meteorological fields as described in any one of claims 1-9.

Images