A Method and System for Constructing CFD Simulation Proxy Models Based on a Storage-Compute Separation Architecture

Abstract

This invention relates to a method and system for constructing a CFD simulation proxy model based on a storage-compute separation architecture: A large model receives task requirements and issues configuration instructions; a model construction initialization tool allocates and locks a shared memory pool in a globally shared tensor pool, assigning it a unique address; raw CFD data is written to this shared memory pool, and the address and metadata are returned to the large model; the large model generates and issues a cleaning call instruction containing a cleaning strategy and the address according to the task requirements; a data cleaning tool directly mounts to this shared memory pool, cleans the CFD training data within it, and after processing, releases the memory lock, returning only a lightweight processing report to the large model; the large model determines that data cleaning is successful based on the processing report, formulates a training strategy according to the current training stage, and generates a training call instruction; an iterative training tool performs a neural network model training loop until convergence, and the shared memory pool stores the optimal parameters of the model.

Description

Technical Field

[0001] This invention relates to the technical field of combining large language models with CFD simulation, and in particular to a method and system for constructing a CFD simulation proxy model based on a storage-compute separation architecture and interaction with a large model. Background Technology

[0002] In existing technologies that utilize Large Language Models (LLM) to automatically construct CFD simulation agent models, there is a common technical bottleneck where interactive visibility and computational execution efficiency cannot be simultaneously achieved.

[0003] Specifically, mainstream solutions typically employ two extreme approaches: one is to encapsulate the entire model training process into a single atomic tool. While this ensures computational continuity, it renders the training process a "black box," preventing users from knowing the model's convergence status over computational cycles lasting hours or even days, thus losing the ability to monitor and intervene in the task in real time. The other approach is to break down the training process into multiple fine-grained tool calls. While this satisfies the need for interaction, the frequent tool switching between conventional atomic tools, which are independent of each other, triggers a large number of data serialization, deserialization, and memory transfer operations, resulting in severe I / O latency and computational performance degradation.

[0004] To address the aforementioned issues, the present invention aims to provide a method and system for constructing a CFD simulation proxy model based on a storage-computation separation architecture and interaction with a large model. This method aims to eliminate data transmission overhead between atomic tools, maintain high computational efficiency, and empower users to perform fine-grained monitoring and dynamic scheduling of the training process through natural language. Summary of the Invention

[0005] This invention addresses the problems and shortcomings of existing technologies by providing a method and system for constructing a CFD simulation proxy model based on a storage-compute separation architecture.

[0006] The present invention solves the above-mentioned technical problems through the following technical solution:

[0007] This invention provides a method for constructing a CFD simulation proxy model based on a storage-computation separation architecture. Its features include a large language model responsible for semantic understanding and task scheduling, a globally shared tensor pool residing in the video memory or RAM of the computing device, and a set of stateless atomic operation tools. The atomic operation tools include model building and initialization tools, data cleaning tools, and iterative training tools. The method includes the following steps:

[0008] S1. The large language model receives the user's model building task requirements and issues configuration instructions.

[0009] S2. The model building and initialization tool receives the configuration instruction, allocates and locks a contiguous storage area in the global shared tensor pool as a shared memory pool, assigns a unique address to the shared memory pool, reads the CFD raw data and parses it into tensor format, writes it into the shared memory pool corresponding to the address, performs memory layout planning and pre-allocation on the shared memory pool, so that it stores the parsed CFD training data, neural network model parameters and initialization, optimizer state and gradient tensor, and returns the address and metadata to the large language model.

[0010] S3, the large language model generates and issues a cleaning call instruction containing the cleaning strategy and the address according to the model building task requirements;

[0011] S4. The data cleaning tool receives the cleaning call instruction, directly mounts the shared memory pool corresponding to the address, performs data cleaning on the CFD training data within it, and releases the memory lock after processing, returning only a lightweight processing report to the large language model.

[0012] S5. The large language model determines whether the data cleaning was successful based on the processing report. If successful, proceed to S6; otherwise, proceed to S7.

[0013] S6. The large language model formulates a training strategy and generates a training call instruction based on the current training stage. The training call instruction also includes the address and step size parameter N. Then proceed to S8.

[0014] S7. The large language model regenerates the cleaning call instruction based on the processing report and submits it to the user for confirmation.

[0015] S8. The iterative training tool receives the training call instruction, directly mounts the shared memory pool corresponding to the address, and performs a neural network model training loop until the model fully converges. The shared memory pool saves the optimal parameters of the CFD simulation proxy model and only returns model convergence information to the large language model.

[0016] This invention also provides a CFD simulation agent model construction system based on a storage-computation separation architecture, characterized in that it includes a large language model responsible for semantic understanding and task scheduling, a globally shared tensor pool residing in the video memory or memory of the computing device, and a set of stateless atomic operation tools, including model building initialization tools, data cleaning tools, and iterative training tools.

[0017] The large language model is used to receive users' model building task requirements and issue configuration instructions;

[0018] The model building and initialization tool receives the configuration instruction, allocates and locks a contiguous storage area in the global shared tensor pool as a shared memory pool, assigns a unique address to the shared memory pool, reads the raw CFD data and parses it into tensor format, writes it into the shared memory pool corresponding to the address, performs memory layout planning and pre-allocation for the shared memory pool, so that it stores the parsed CFD training data, neural network model parameters and initialization, optimizer state and gradient tensor, and returns the address and metadata to the large language model.

[0019] The large language model is used to generate and issue cleaning call instructions containing the cleaning strategy and the address according to the model building task requirements;

[0020] The data cleaning tool receives the cleaning call instruction, directly mounts the shared memory pool corresponding to the address, cleans the CFD training data within it, releases the memory lock after processing, and only returns a lightweight processing report to the large language model.

[0021] The large language model is used to determine whether data cleaning is successful based on the processing report. If successful, it formulates a training strategy and generates a training call instruction based on the current training stage. The training call instruction also includes the address and step size parameter N. If it fails, it regenerates the cleaning call instruction based on the processing report and submits it to the user for confirmation.

[0022] The iterative training tool receives the training call instruction, directly mounts the shared memory pool corresponding to the address, and performs a neural network model training loop until the model fully converges. The shared memory pool stores the optimal parameters of the CFD simulation proxy model and only returns model convergence information to the large language model.

[0023] The present invention also provides an electronic device, characterized in that it includes: a processor; a memory for storing processor-executable instructions; wherein the processor is configured to invoke the instructions stored in the memory to execute the above-described CFD simulation proxy model construction method.

[0024] The present invention also provides a computer-readable storage medium storing computer program instructions thereon, characterized in that the computer program instructions, when executed by a processor, implement the above-described CFD simulation proxy model construction method.

[0025] The positive and progressive effects of this invention are as follows:

[0026] This invention constructs a storage-computation separation execution architecture based on a globally shared tensor pool. Unlike existing technologies where tools need to transfer entity data via I / O, this invention allocates a global storage space in the high-speed memory or video memory of the computing device to uniformly store neural network model parameters, optimizer states, and training data. All atomic tools are designed as stateless pure computation operators, requiring only an address pointer to the shared memory pool to directly perform in-place operations on the data. This fundamentally eliminates the overhead of data copying and context switching during multiple iterations, ensuring computational efficiency comparable to the native training process.

[0027] This invention proposes a dynamic segmented iterative control mechanism based on natural language commands. This invention abandons the fixed training cycle model, allowing large language models to dynamically generate calling commands containing an "iteration step" parameter based on user intent or current task feedback (such as the loss convergence curve). The atomic training tool automatically suspends and returns the current intermediate state metric after executing the specified number of steps, rather than terminating the process. This mechanism enables users or agents to flexibly switch between "long-cycle, high-efficiency computation" and "short-cycle, high-frequency interaction" with extremely low interaction costs, achieving observability and controllability throughout the entire lifecycle of CFD simulation agent model construction. Attached Figure Description

[0028] Figure 1 This is a schematic diagram illustrating a preferred embodiment of the present invention based on a storage-compute separation architecture and its interaction with a large model.

[0029] Figure 2 This is a schematic diagram of the interaction process according to a preferred embodiment of the present invention. Detailed Implementation

[0030] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, 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, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0031] like Figure 1-2As shown, this embodiment of the invention provides a method for constructing a CFD simulation proxy model based on a storage-compute separation architecture, including a large language model (LLM) responsible for semantic understanding and task scheduling, a global shared tensor pool residing in the video memory or memory of a high-performance computing device (such as a GPU), and a set of stateless atomic operation tools. The atomic operation tools include model building initialization tools, data cleaning tools, iterative training tools, inference derivation tools, and visualization tools.

[0032] This embodiment designs an architecture of "in-memory / compute separation (shared GPU memory / RAM) + dynamic segmentation control of large models". The atomic operation toolset serves as the execution endpoint of this in-memory / compute separation architecture. Each tool is designed as a stateless, independent computing unit, focusing on executing a single logic (such as data cleaning, training, or inference). They all reside in a shared memory environment, achieving "zero-copy" data transfer solely through memory addresses. Under the unified scheduling of the large language model, these tools are dynamically orchestrated according to task instructions, efficiently and collaboratively completing the entire lifecycle from raw data processing to the construction of the CFD simulation proxy model.

[0033] 1. Model building and initialization tools

[0034] 1) Tool definition and role

[0035] The model building and initialization tool acts as both an "infrastructure builder" and a "memory lifecycle manager." Throughout the entire workflow, it is typically the first critical tool invoked by the Large Language Model (LLM). Its core role is to break down the traditional memory barriers between processes, establishing a unified, high-performance data interaction platform for the system. It is responsible for creating and managing a "Global Shared Tensor Pool" in computing hardware (such as GPU memory or high-performance RAM), ensuring that all subsequent computational tasks can be executed efficiently within a shared context. Overall, the model building and initialization tool guarantees three key characteristics: contiguous memory, unique addresses, and pre-partitioned regions.

[0036] 2) Core Function Description

[0037] This tool receives configuration instructions from a large language model (such as model type, tensor dimension, and accuracy requirements) and performs the following key operations:

[0038] Shared memory pool allocation: The model building and initialization tools call the underlying system interface (such as CUDA IPC or POSIX Shared Memory) to lock and allocate a contiguous storage area in physical video memory or system memory as a shared memory pool. The shared memory pool differs from the private stack of a regular application and is defined as a public domain accessible to all atomic tools.

[0039] Unified Handle Generation Mechanism: The model building initialization tool assigns a unique identifier (Handle) or memory address pointer to this shared memory pool. This handle / address is the only "passport" in the system, and all subsequent tools (cleaning, training, inference) locate data by passing this handle / address, without passing the actual data payload.

[0040] Memory layout planning and pre-allocation: The model building initialization tool pre-divides functional areas within the shared memory pool based on the predicted computational load.

[0041] 3) System-level significance and interaction

[0042] This tool is a prerequisite for achieving the core technical effects of this application—"zero-copy" and "in-place operation"—.

[0043] Interaction flow: The large language model issues build instructions - the tool performs memory allocation - the tool returns the "memory address" to the large language model.

[0044] Architectural Value: Through the initialization of this tool, the system avoids the frequent data serialization and deserialization overhead between toolchains in traditional pipelines. It turns data into a "static" resource, allowing computational tools to move around the data, thereby greatly reducing I / O latency and enabling high-frequency intervention of large models in the underlying simulation process.

[0045] 2. Data cleaning tools

[0046] 1) Tool definition and role

[0047] The data cleaning tool is a stateless, atomic computational unit in this system, primarily responsible for preprocessing and quality optimization of the raw CFD simulation data residing in the "global shared tensor pool." It acts as a "data purifier," aiming to eliminate noise, outliers, and dimensional differences in the raw physics data, thereby improving the training convergence speed and prediction accuracy of subsequent surrogate models.

[0048] 2) Core Function Description

[0049] This tool receives configuration instructions and memory addresses from the Large Language Model (LLM) and mainly performs the following three types of data processing operations: outlier handling, feature engineering and dimensionality reduction, and data distribution reshaping and normalization.

[0050] 3) Interaction mechanism with the system

[0051] Unlike traditional data processing workflows, this tool does not perform data upload or download.

[0052] Instruction reception: The large language model generates a call instruction containing the "cleaning strategy (such as using Min-Max)" and the "target data memory address" according to the current task requirements.

[0053] In-Place Operation: The data cleaning tool directly mounts the globally shared tensor pool based on the address, and directly performs matrix operations on the original tensors in video memory / memory to modify them.

[0054] Status feedback: After processing is complete, the tool releases the memory lock and returns only a lightweight processing report (such as the number of outliers removed, the feature retention ratio, and the normalized statistical distribution parameters) to the large language model, so that the large model can determine whether to proceed to the next step.

[0055] 3. Iterative training tools

[0056] 1) Tool definition and role

[0057] The iterative training tool is the core computational engine of this system, responsible for executing the parameter update and optimization process of the neural network. Unlike the long-term resident training process in traditional deep learning frameworks, this tool is designed as a stateless atomic computation operator. It does not hold any model parameters or training state, but relies entirely on the data in the "globally shared tensor pool" for operation. In the system flow, it accepts dynamic scheduling from the Large Language Model (LLM), acting as the "executor" and achieving complete decoupling between computational logic and state storage.

[0058] 2) Core working logic

[0059] The tool's execution process follows a short-cycle pattern of "mount-compute-release," with the specific logic as follows:

[0060] Input parameter parsing: The iterative training tool receives two key parameters from the large language model: (1) Global shared memory address: used to locate training data and model parameters. (2) Steps / Epochs = N: specifies the number of training rounds (Epoch) or iterations (Iteration) to be executed in this atomic operation.

[0061] State mounting and breakpoint continuation: Using the passed-in address, the iterative training tool directly maps the virtual address space of the current computation process to the global shared tensor pool. The iterative training tool directly reads the model weights, gradients, and optimizer state stored in the shared memory pool from the "previous time step," seamlessly continuing the training progress without any data copying.

[0062] On-demand iterative computation: The iterative training tool starts an internal training loop, and the number of executions is strictly controlled by parameter N. In each loop: (1) Forward propagation is performed to calculate the loss function between the predicted and true values; (2) Backward propagation is performed to calculate the gradient; (3) The optimizer is called to update the model parameters in the shared pool. (4) Boundary judgment logic: During the loop, the tool will check in real time whether the current cumulative number of Epochs has reached the preset maximum total training cycle limit (Max Epochs). Once the limit is reached, even if parameter N has not been completed, the tool will force the computation to end early to prevent overfitting or waste of resources.

[0063] Status Feedback and Release: After completing N iterations or triggering the termination condition, the iterative training tool immediately releases the lock on the shared memory or retains the mapping in standby mode and exits the computation state. At this time, the iterative training tool only returns lightweight metadata (JSON format) containing the training state, mainly including: (1) the latest Loss value (used to draw the convergence curve); (2) the current cumulative number of Epochs; (3) the execution time and peak memory usage of this execution.

[0064] 3) System-level advantages

[0065] The design of this tool embodies the core value of the invention: "interactive controllability".

[0066] Fine-grained observability: By breaking down the lengthy training process into a series of short tasks consisting of N steps, users and large language models can “peek” into the model’s internal workings through the returned state data after each N steps.

[0067] Dynamic scheduling capability: Users (or LLMs) can dynamically adjust the N value of the next instruction based on the returned loss decline trend. For example, a larger N (such as 100) can be set in the early stage of training when the loss declines rapidly to improve efficiency; a smaller N (such as 10) can be set in the later stage of training when the loss oscillates, and the learning rate can be adjusted in conjunction with this to achieve precise optimization.

[0068] 4. Inference and Derivation Tools

[0069] 1) Tool definition and role

[0070] The inference export tool is the application interface used by this system to verify model performance and generate final simulation data. This tool is typically invoked after the model has fully converged. Its core function is to transform the trained neural network model into actual physical field prediction capabilities, rapidly generating CFD simulation results such as flow and pressure fields based on new operating conditions input by the user. Furthermore, this tool is also responsible for the persistent storage (export) of model parameters.

[0071] 2) Dual-mode working mechanism

[0072] To balance the convenience of "online interaction" with the versatility of "offline deployment," the tool is designed with two data reading modes, which users or large language models can freely switch between depending on the scenario. Moreover, in a single inference task, the latency difference between the two modes on the user experience is negligible.

[0073] Mode 1: In-Memory Inference. (1) Suitable for intermediate state verification during training or immediate prediction immediately after training. (2) The tool receives the address of the "shared memory pool" and directly uses the existing model weights and structure in the video memory to perform a forward pass. This mode does not require waiting for the parameters to be saved to the hard disk, and fully realizes the seamless switching between "training-inference", which is particularly suitable for quickly evaluating the generalization ability of large models in closed-loop control.

[0074] Mode 2: Offline Cold Inference (File-Based Inference). (2) Applicable to scenarios after system restart or when the model has been deployed to other non-training nodes. (2) The tool reads the archived model parameter file (such as .pt or .onnx file) on the disk, loads it into memory to reconstruct the network structure, and then performs prediction.

[0075] 5. Visualization tools

[0076] 1) Tool definition and role

[0077] The visualization tool is a functional component in this system responsible for "data post-processing and human-computer interaction presentation." In the construction and application process of the CFD simulation proxy model, it acts as a "translator." Since the output of neural networks (and the default results generated by the inference derivation tool) is usually high-dimensional tensors or general HDF5 (Hierarchical Data Format) data, this data lacks physical topology information and is difficult for engineers to understand directly. The purpose of this tool is to map these abstract numerical matrices back to the physical grid space, transforming them into an industry-standard fluid dynamics visualization format, thereby closing the loop for users' verification needs.

[0078] 2) Core Workflow

[0079] This tool responds to user viewing requests or is automatically invoked after the large language model has completed its judgment task. It mainly executes the following logic:

[0080] Heterogeneous data reading: The tool first loads the inference result file generated by the "Inference Export Tool". By default, the file is stored in HDF5 format, which is an efficient binary container that supports large-scale scientific computing data. It contains flow field predictions (such as velocity components u, v, w and pressure p, temperature T) and corresponding tensor metadata.

[0081] Topology Reconstruction and Mapping: The tool internally maintains the mesh topology information of the original computational domain. It reads tensor data from HDF5 and remaps it to the physical mesh coordinate system according to the node index or cell index, restoring the spatial properties of the data.

[0082] Format transcoding and output: The tool incorporates interface protocols from various industrial-grade CFD software to convert the reconstructed data stream into specific visualization file formats.

[0083] Conversion for ParaView: Generates VTK (Visualization Toolkit) series formats (such as .vts, .vtk, .vtu, .vtm), supporting post-processing analysis commonly used in the open-source community.

[0084] Transformation for Tecplot: Generates .plt format files in binary or ASCII encoding, supporting commercial-grade high-precision flow field rendering and cross-sectional analysis.

[0085] 3) System-level significance

[0086] The existence of this tool enables the output of this invention to be seamlessly integrated into the existing mature CAE industrial ecosystem. Engineers can open the prediction results generated by this system using their familiar professional software (ParaView or Tecplot) without changing their original analysis habits, and perform streamline tracing, isosurface extraction, and flow field cloud map comparison, thereby intuitively evaluating the accuracy of the simulation proxy model generated by the large model.

[0087] like Figure 1-2 As shown, the method for constructing a CFD simulation proxy model based on a storage-compute separation architecture includes the following steps:

[0088] S1, the large language model receives the user's model building task requirements (such as "build a flow field prediction model based on U-Net") and issues configuration instructions.

[0089] S2. The model building and initialization tool receives the configuration instruction, allocates and locks a contiguous storage area in the global shared tensor pool as a shared memory pool, assigns a unique address (identifier (Handle) or memory address pointer) to the shared memory pool, reads the raw CFD data (such as flow field velocity and pressure field data) and parses it into tensor format, writes it into the shared memory pool corresponding to the address, performs memory layout planning and pre-allocation for the shared memory pool, so that it stores the parsed CFD training data, neural network model parameters and initialization, optimizer state and gradient tensor, and returns the address and metadata (such as tensor dimension and data type) to the large language model.

[0090] In S2, the model building initialization tool plans and pre-allocates the memory layout of the shared memory pool according to the predicted computational load, dividing it into a data storage area, a model parameter area, an optimizer state area, and a gradient buffer. Among them, (1) Data storage area: persistently stores the parsed CFD training data (such as flow field grid point data); (2) Model parameter area: allocates space for the weight matrix and bias vector of the neural network (such as CNN, Transformer), and performs random initialization or pre-trained weight loading; (3) Optimizer state area: reserves space to store the intermediate states (Optimizer State, such as momentum, variance) required by the optimizer (such as Adam, SGD); (4) Gradient buffer: temporarily stores the gradient tensors generated during backpropagation.

[0091] S3, the large language model generates and issues a cleaning call instruction containing the cleaning strategy and the address based on the model building task requirements.

[0092] S4. The data cleaning tool receives the cleaning call instruction, directly mounts the shared memory pool corresponding to the address, performs data cleaning on the CFD training data within it, and releases the memory lock after processing, returning only a lightweight processing report to the large language model.

[0093] In S4, the data cleaning tool cleans the CFD training data:

[0094] Anomaly Detection and Correction: The data cleaning tool performs a statistical scan of the CFD training data within the shared memory pool, identifying anomalies that exceed physical limitations or statistical thresholds (e.g., Outliers (in accordance with the principle) are removed or numerically corrected using neighborhood interpolation algorithms to prevent “dirty data” from causing gradient explosion in the model.

[0095] Feature engineering and dimensionality reduction: The data cleaning tool performs correlation analysis on the features of the data after anomaly detection and correction. Based on the analysis results, it automatically identifies and removes duplicate features (highly collinear features) or weakly correlated features (features that contribute very little to the flow field changes). The tool supports the simplification or redefinition of features, thereby reducing data dimensionality, reducing memory usage, and improving computational efficiency.

[0096] Data Distribution Reshaping and Normalization: Data cleaning tools redistribute the data after feature engineering and dimensionality reduction to adapt to the requirements of neural networks for input data distribution, and perform data standardization or normalization. In order to adapt to the requirements of neural networks for input data distribution, the tool redistributes the data in the tensor pool. It supports multiple standardization strategies, which are dynamically selected through LLM instructions. Common algorithms include: (1) z-score standardization. Converts the data into a distribution with a mean of 0 and a standard deviation of 1; (2) min-max normalization. Linearly maps the data to the interval [0,1].

[0097] S5. The large language model determines whether the data cleaning was successful based on the processing report. If successful, proceed to S6; otherwise, proceed to S7.

[0098] S6. The large language model formulates a training strategy and generates a training call instruction based on the current training stage. The training call instruction also includes the address and step size parameter N, and then proceeds to S8.

[0099] S7. The large language model regenerates the cleaning call instruction based on the processing report and submits it to the user for confirmation.

[0100] S8. The iterative training tool receives the training call instruction, directly mounts the shared memory pool corresponding to the address, and performs a neural network model training loop until the model fully converges. The shared memory pool saves the optimal parameters of the CFD simulation proxy model and only returns model convergence information to the large language model.

[0101] S8 specifically includes:

[0102] S81. The iterative training tool receives the training call instruction, directly mounts the shared memory pool corresponding to the address, and performs a neural network model training loop. In this step, based on the passed address, the global shared tensor pool is mapped to the address space of the current computing process (i.e., the shared memory pool), thereby obtaining model parameters and training data with zero copy.

[0103] S82. In each loop, the iterative training tool performs forward propagation, calculates the loss function between the predicted and true values, performs backpropagation to calculate the gradient, and uses the optimizer to update the model parameters in the shared memory pool. It determines whether the number of loops has reached the step size parameter N or whether the current cumulative number of Epochs has reached the preset total training cycle limit. Once either condition is met, the calculation stops immediately, the current loss value Loss is calculated, the lock on the shared memory pool is immediately released or the mapping is reserved for standby, and only a lightweight state packet containing the training state is returned to the large language model. The training state includes the latest loss value Loss, the current cumulative number of Epochs, and the peak execution time and memory usage of this execution.

[0104] S83. After receiving the returned status packet, the large language model performs a logical judgment on the convergence trend of the loss value: 1. If convergence has not occurred, the next round of training call instructions is automatically generated: If the loss value has not reached the preset threshold and shows a decreasing trend, the next round of training call instructions is automatically generated and the step size parameter N is dynamically adjusted. Specifically, a relatively large step size parameter N (e.g., 100) is set when the loss value decreases rapidly in the early stage of training, and a relatively small step size parameter N (e.g., 50) is set when the loss value decreases slowly in the middle stage of training; if the loss value has not reached the preset threshold and shows an oscillating trend, the next round of training call instructions is automatically generated and the step size parameter N and the learning rate in the model parameters are dynamically adjusted, with the step size parameter N set to a relatively small number (e.g., 10). 2. If convergence has occurred, the shared memory pool saves the optimal parameters of the CFD simulation proxy model and only returns model convergence information to the large language model.

[0105] S84. The iterative training tool uses the address in the next round of training call instructions to directly map the virtual address space of the current computing process to the memory shared pool, directly reads the data stored in the memory shared pool from the previous moment, seamlessly continues the previous training progress, and executes S82 again.

[0106] The closed-loop process of "generating instructions - tool execution - status feedback - logical judgment" continues until the convergence condition is met.

[0107] S9. The large language model receives the new operating conditions input by the user (i.e., the input variables in the CFD simulation) and sends the new operating conditions and the address to the inference and export tool.

[0108] S10. The inference and export tool directly mounts the shared memory pool corresponding to the address, uses the optimal parameters of the CFD simulation proxy model stored in the shared memory pool to make predictions, outputs simulation prediction results, exports simulation prediction results (such as velocity field and temperature field data), and serializes the optimal parameters of the CFD simulation proxy model stored in the shared memory pool and writes them to the hard disk to complete the solidification and storage of the model.

[0109] S11. The visualization tool responds to the user's viewing needs or is automatically invoked after the large language model judgment task is completed. The visualization tool loads the simulation prediction results generated by the inference export tool and stored in HDF5 format. The simulation prediction results include flow field prediction values ​​and corresponding tensor metadata. The visualization tool reads the tensor metadata and remaps it to the physical grid coordinate system by node index or cell index to restore the spatial properties of the data. The visualization tool has built-in interface protocols of various industrial-grade CFD software to convert the reconstructed data stream into a specific visualization file format.

[0110] This invention also provides a CFD simulation agent model building system based on a storage-compute separation architecture, including a large language model responsible for semantic understanding and task scheduling, a globally shared tensor pool residing in the video memory or memory of the computing device, and a set of stateless atomic operation tools, including model building initialization tools, data cleaning tools, and iterative training tools.

[0111] The large language model is used to receive users' model building task requirements and issue configuration instructions.

[0112] The model building and initialization tool receives the configuration instruction, allocates and locks a contiguous storage area in the global shared tensor pool as a shared memory pool, assigns a unique address to the shared memory pool, reads the raw CFD data and parses it into tensor format, writes it to the shared memory pool corresponding to the address, performs memory layout planning and pre-allocation on the shared memory pool, so that it stores the parsed CFD training data, neural network model parameters and initialization, optimizer state and gradient tensor, and returns the address and metadata to the large language model.

[0113] The large language model is used to generate and issue cleaning invocation instructions containing the cleaning strategy and the address, based on the model building task requirements.

[0114] The data cleaning tool receives the cleaning call instruction, directly mounts the shared memory pool corresponding to the address, performs data cleaning on the CFD training data within it, releases the memory lock after processing, and only returns a lightweight processing report to the large language model.

[0115] The large language model is used to determine whether data cleaning is successful based on the processing report. If successful, it formulates a training strategy and generates a training call instruction based on the current training stage. The training call instruction also includes the address and step size parameter N. If it fails, it regenerates the cleaning call instruction based on the processing report and submits it to the user for confirmation.

[0116] The iterative training tool receives the training call instruction, directly mounts the shared memory pool corresponding to the address, and performs a neural network model training loop until the model fully converges. The shared memory pool stores the optimal parameters of the CFD simulation proxy model and only returns model convergence information to the large language model.

[0117] The innovation of this invention lies in the organic combination of a "global storage-computation separation architecture" and a "dynamic step-size interaction mechanism," specifically including:

[0118] First, this invention constructs a storage-computation separation execution architecture based on a globally shared tensor pool. Unlike existing technologies where tools need to transfer entity data via I / O, this invention allocates a global storage space in the high-speed memory or video memory of the computing device to uniformly store neural network model parameters, optimizer states, and training data. All atomic tools are designed as stateless pure computation operators, requiring only an address pointer to the shared memory pool to directly perform in-place operations on the data. This fundamentally eliminates the overhead of data copying and context switching during multiple iterations, ensuring computational efficiency comparable to the native training process.

[0119] Secondly, this invention proposes a dynamic segmented iterative control mechanism based on natural language commands. This invention abandons the fixed training cycle model, allowing the large language model to dynamically generate calling commands containing an "iteration step" parameter based on user intent or current task feedback (such as the loss convergence curve). The atomic training tool automatically suspends and returns the current intermediate state metric after executing the specified number of steps, rather than terminating the process. This mechanism enables users or agents to flexibly switch between "long-cycle, high-efficiency computation" and "short-cycle, high-frequency interaction" with extremely low interaction costs, achieving observability and controllability throughout the entire lifecycle of CFD simulation agent model construction.

[0120] This invention also provides an electronic device, including: a processor; a memory for storing processor-executable instructions; wherein the processor is configured to invoke the instructions stored in the memory to execute the aforementioned method.

[0121] This invention also provides a computer-readable storage medium storing computer program instructions thereon, which, when executed by a processor, implement the aforementioned method.

[0122] This invention can be a method, apparatus, system, and / or computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for performing various aspects of the invention.

[0123] While specific embodiments of the present invention have been described above, those skilled in the art should understand that these are merely illustrative examples, and the scope of protection of the present invention is defined by the appended claims. Those skilled in the art can make various changes or modifications to these embodiments without departing from the principles and essence of the present invention, and all such changes and modifications fall within the scope of protection of the present invention.

Claims

1. A method for constructing a CFD simulation proxy model based on a storage-compute separation architecture, characterized in that, It includes a large language model responsible for semantic understanding and task scheduling, a globally shared tensor pool residing in the GPU memory or RAM of the computing device, and a set of stateless atomic operation tools. The atomic operation tools include model building and initialization tools, data cleaning tools, and iterative training tools. The method includes the following steps: S1. The large language model receives the user's model building task requirements and issues configuration instructions. S2. The model building and initialization tool receives the configuration instruction, allocates and locks a contiguous storage area in the global shared tensor pool as a shared memory pool, assigns a unique address to the shared memory pool, reads the CFD raw data and parses it into tensor format, writes it into the shared memory pool corresponding to the address, performs memory layout planning and pre-allocation on the shared memory pool, so that it stores the parsed CFD training data, neural network model parameters and initialization, optimizer state and gradient tensor, and returns the address and metadata to the large language model. S3, the large language model generates and issues a cleaning call instruction containing the cleaning strategy and the address according to the model building task requirements; S4. The data cleaning tool receives the cleaning call instruction, directly mounts the shared memory pool corresponding to the address, performs data cleaning on the CFD training data within it, and releases the memory lock after processing, returning only a lightweight processing report to the large language model. S5. The large language model determines whether the data cleaning was successful based on the processing report. If successful, proceed to S6; otherwise, proceed to S7. S6. The large language model formulates a training strategy and generates a training call instruction based on the current training stage. The training call instruction also includes the address and step size parameter N. Then proceed to S8. S7. The large language model regenerates the cleaning call instruction based on the processing report and submits it to the user for confirmation. S8. The iterative training tool receives the training call instruction, directly mounts the shared memory pool corresponding to the address, and performs a neural network model training loop until the model fully converges. The shared memory pool saves the optimal parameters of the CFD simulation proxy model and only returns model convergence information to the large language model.

2. The method for constructing a CFD simulation proxy model based on a storage-compute separation architecture as described in claim 1, characterized in that, In S2, the model building initialization tool plans and pre-allocates the memory layout of the shared memory pool based on the predicted computational load, dividing it into a data storage area, a model parameter area, an optimizer state area, and a gradient buffer. The data storage area persistently stores the parsed CFD training data. The model parameter area allocates space for the weight matrix and bias vector of the neural network and performs random initialization or pre-training weight loading. The optimizer state area reserves space to store the intermediate states required by the optimizer. The gradient buffer temporarily stores the gradient tensors generated during backpropagation.

3. The method for constructing a CFD simulation proxy model based on a storage-compute separation architecture as described in claim 1, characterized in that, In S4, the data cleaning tool cleans the CFD training data: Anomaly detection and correction: The data cleaning tool performs a statistical scan of the CFD training data in the shared memory pool. For outliers that exceed physical limits or statistical thresholds, it performs removal operations or uses neighborhood interpolation algorithms for numerical correction. Feature engineering and dimensionality reduction: Data cleaning tools perform correlation analysis on the features of data after anomaly detection and correction. Based on the analysis results, they automatically identify and remove duplicate features, i.e., highly collinear features or weakly correlated features, i.e., features that contribute very little to the flow field changes. Data distribution reshaping and normalization: Data cleaning tools redistribute the feature-engineered and dimensionality-reduced data to adapt to the requirements of neural networks for input data distribution, and perform data standardization or normalization.

4. The method for constructing a CFD simulation proxy model based on a storage-compute separation architecture as described in claim 1, characterized in that, S8 specifically includes: S81. The iterative training tool receives the training call instruction, directly mounts the shared memory pool corresponding to the address, and performs a neural network model training loop. S82. In each loop, the iterative training tool performs forward propagation, calculates the loss function between the predicted value and the true value, performs backpropagation to calculate the gradient, and uses the optimizer to update the model parameters in the shared memory pool. It determines whether the number of loops has reached the step size parameter N or whether the current cumulative number of Epochs has reached the preset total training cycle limit. Once one of the conditions is met, the calculation is stopped immediately, the current loss value Loss is calculated, the lock on the shared memory pool is immediately released or the mapping is reserved for standby, and only a lightweight state packet containing the training state is returned to the large language model. S83. After receiving the returned status packet, the large language model makes a logical judgment on the convergence trend of the loss value. If it has not converged, it automatically generates the next round of training call instructions. If it has converged, the shared memory pool saves the optimal parameters of the CFD simulation proxy model and only returns the model convergence information to the large language model. S84. The iterative training tool uses the address in the next round of training call instructions to directly map the virtual address space of the current computing process to the shared memory pool, directly reads the data stored in the shared memory pool from the previous moment, seamlessly continues the previous training progress, and executes S82 again.

5. The method for constructing a CFD simulation proxy model based on a storage-compute separation architecture as described in claim 4, characterized in that, In S82, the training status includes the latest loss value, the current cumulative number of epochs, and the peak execution time and memory usage of this session; In S83, if the loss value Loss does not reach the preset threshold and shows a downward trend, the next round of training call instruction is automatically generated and the step size parameter N is dynamically adjusted. If the loss value does not reach the preset threshold and shows an oscillating trend, the next round of training call instructions will be automatically generated and the step size parameter N and the learning rate in the model parameters will be dynamically adjusted.

6. The method for constructing a CFD simulation proxy model based on a storage-compute separation architecture as described in claim 1, characterized in that, The atomization toolset also includes inference derivation tools; After S8, S9 and the large language model receive the new working condition input by the user and send the new working condition and the address to the inference and export tool. S10. The inference and export tool directly mounts the shared memory pool corresponding to the address, uses the optimal parameters of the CFD simulation proxy model stored in the shared memory pool to make predictions, outputs the simulation prediction results, exports the simulation prediction results, and serializes and writes the optimal parameters of the CFD simulation proxy model stored in the shared memory pool to the hard disk, thus completing the solidification and storage of the model.

7. The method for constructing a CFD simulation proxy model based on a storage-compute separation architecture as described in claim 6, characterized in that, The atomization toolset also includes visualization tools; Following S10, S11, the visualization tool responds to user viewing needs or is automatically invoked after the large language model judgment task is completed. The visualization tool loads the simulation prediction results generated by the inference export tool and stored in HDF5 format. The simulation prediction results include flow field prediction values ​​and corresponding tensor metadata. The visualization tool reads the tensor metadata and remaps it to the physical grid coordinate system by node index or cell index to restore the spatial properties of the data. The visualization tool has built-in interface protocols of various industrial-grade CFD software to convert the reconstructed data stream into a specific visualization file format.

8. A CFD simulation proxy model construction system based on a storage-compute separation architecture, characterized in that, It includes a large language model responsible for semantic understanding and task scheduling, a globally shared tensor pool residing in the video memory or memory of the computing device, and a set of stateless atomic operation tools, including model building and initialization tools, data cleaning tools, and iterative training tools; The large language model is used to receive users' model building task requirements and issue configuration instructions; The model building and initialization tool receives the configuration instruction, allocates and locks a contiguous storage area in the global shared tensor pool as a shared memory pool, assigns a unique address to the shared memory pool, reads the raw CFD data and parses it into tensor format, writes it into the shared memory pool corresponding to the address, performs memory layout planning and pre-allocation for the shared memory pool, so that it stores the parsed CFD training data, neural network model parameters and initialization, optimizer state and gradient tensor, and returns the address and metadata to the large language model. The large language model is used to generate and issue cleaning call instructions containing the cleaning strategy and the address according to the model building task requirements; The data cleaning tool receives the cleaning call instruction, directly mounts the shared memory pool corresponding to the address, cleans the CFD training data within it, releases the memory lock after processing, and only returns a lightweight processing report to the large language model. The large language model is used to determine whether data cleaning is successful based on the processing report. If successful, it formulates a training strategy and generates a training call instruction based on the current training stage. The training call instruction also includes the address and step size parameter N. If it fails, it regenerates the cleaning call instruction based on the processing report and submits it to the user for confirmation. The iterative training tool receives the training call instruction, directly mounts the shared memory pool corresponding to the address, and performs a neural network model training loop until the model fully converges. The shared memory pool stores the optimal parameters of the CFD simulation proxy model and only returns model convergence information to the large language model.

9. An electronic device, characterized in that, include: processor; Memory used to store processor-executable instructions; The processor is configured to invoke instructions stored in memory to execute the CFD simulation proxy model construction method according to any one of claims 1-7.

10. A computer-readable storage medium having computer program instructions stored thereon, characterized in that, When the computer program instructions are executed by the processor, they implement the CFD simulation proxy model construction method according to any one of claims 1-7.

Images