Method for dynamically constructing cfd simulation proxy model based on large language model

Abstract

The application relates to the technical field of intelligent construction of CFD agent models, and discloses a CFD simulation agent model dynamic construction method based on a large language model. The method comprises the following steps: intelligently analyzing input condition parameters of CFD simulation by using the large language model, and automatically generating initial demand prediction of the agent model. In the simulation process, a flow field data sequence is collected in real time, feature extraction is carried out by using the large language model for context perception, and accurate actual model demand parameters are obtained. The large language model dynamically generates an optimal agent model structure description, which is automatically converted into executable source code text, and finally the instant construction of the agent model is completed. The method realizes the full-process automation of the agent model from demand analysis to code generation, improves the model construction efficiency, and enhances the prediction accuracy and practicability of the agent model through adaptive optimization of the simulation scene.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of intelligent construction of CFD proxy model, in particular to a CFD simulation proxy model dynamic construction method based on a large language model. BACKGROUND

[0002] Computational fluid dynamics (CFD) simulation is crucial in engineering design and scientific research, but it is computationally expensive and time-consuming. To accelerate this process, proxy model technology is widely used, which predicts the flow field behavior by building an approximate model with much lower computational cost than the original simulation. Existing proxy model construction methods usually rely on pre-defined model templates or fixed machine learning processes, such as directly selecting standard feedforward neural networks or Gaussian process models. The structural parameters of the model need to be pre-set by domain experts based on experience or determined through extensive trial and error. This construction process is static, and once the model structure is determined, it usually remains unchanged throughout the simulation application period, making it difficult to adapt to the dynamic changes in flow field characteristics under different input conditions or simulation stages.

[0003] In the feature processing link, existing technologies rely on manually designed feature engineering or fixed dimensionality reduction algorithms to extract key information from flow field data. This method cannot adaptively select and evaluate features based on the specific simulation physical background and numerical characteristics. The entire proxy model implementation code needs to be manually completed by developers, from programming implementation of model structure to interface integration with simulation program, which consumes a lot of manpower and is prone to errors. The existing technical system is obviously rigid, and the construction process relies heavily on human intervention and prior knowledge, which cannot achieve end-to-end automation and intelligentization, restricting the flexibility and application efficiency of proxy models in complex and variable CFD applications. SUMMARY

[0004] The purpose of the present application is to provide a CFD simulation proxy model dynamic construction method based on a large language model to solve the problems raised in the background.

[0005] To achieve the above purpose, the present application provides a CFD simulation proxy model dynamic construction method based on a large language model, which comprises:

[0006] Analyzing the input condition parameter set of the CFD simulation based on the large language model, generating proxy model demand prediction parameters;

[0007] According to the proxy model demand prediction parameters, collecting the flow field data sequence in the CFD simulation process, and using the large language model to extract features from the flow field data sequence to obtain actual model demand parameters;

[0008] Processing the actual model demand parameters through the large language model to dynamically generate proxy model structure description parameters;

[0009] generating a proxy model source code text using a large language model based on the proxy model structure description parameter;

[0010] converting the proxy model source code text into an executable proxy model to complete proxy model construction.

[0011] Preferably, the large language model is used to analyze the input condition parameter set of the CFD simulation to generate a proxy model demand prediction parameter, including:

[0012] obtaining geometric parameters, boundary condition parameters and material attribute parameters of the CFD simulation case to form an input condition parameter set;

[0013] inputting the input condition parameter set into a pre-trained large language model, wherein the large language model is trained based on CFD simulation historical data;

[0014] the large language model outputs a proxy model type prediction result as a proxy model demand prediction parameter.

[0015] Preferably, the flow field data sequence in the CFD simulation process is collected according to the proxy model demand prediction parameter, including:

[0016] starting CFD simulation calculation to run the simulation case;

[0017] recording the numerical distribution of the flow field variables including velocity distribution, pressure distribution and temperature distribution regularly during the simulation iteration process;

[0018] arranging the numerical distribution recorded multiple times in time sequence to form a flow field data sequence.

[0019] Preferably, the large language model is used to extract features from the flow field data sequence to obtain an actual model demand parameter, including:

[0020] selecting a feature recognition module in the large language model according to the proxy model demand prediction parameter;

[0021] inputting the flow field data sequence into the feature recognition module to perform data pattern analysis and key feature recognition;

[0022] outputting the feature recognition result as an actual model demand parameter.

[0023] Preferably, the large language model is used to process the actual model demand parameter to dynamically generate a proxy model structure description parameter, including:

[0024] inputting the actual model demand parameter into a structure generation module of the large language model;

[0025] The large language model generates a network architecture description of the proxy model based on the actual model requirement parameters;

[0026] The network architecture description is parsed to obtain the proxy model structure description parameters.

[0027] Preferably, the step of generating proxy model source code text using a large language model based on the proxy model structure description parameters includes:

[0028] The large language model generates the code content of the machine learning model based on the parameters described by the agent model structure.

[0029] The code content includes model layer definitions, loss functions, and training algorithms;

[0030] Output the generated proxy model source code text.

[0031] Preferably, the step of converting the proxy model source code text into an executable proxy model includes:

[0032] The source code text of the proxy model is compiled using a code compiler;

[0033] Link runtime library files to generate executable code files;

[0034] Check the correctness of the executable code file and output the executable proxy model.

[0035] Preferably, the method further includes performing verification tests on the executable proxy model to obtain a verified proxy model, wherein the verification tests include:

[0036] Run the executable proxy model in the validation case and obtain the proxy model output data;

[0037] Compare the output data of the proxy model with the output data of the standard CFD simulation, and calculate the difference metric.

[0038] The suitability of a proxy model is determined based on the difference metric.

[0039] Preferably, after determining whether the proxy model is qualified based on the difference metric, the method further includes adjusting the proxy model parameters, wherein adjusting the proxy model parameters includes:

[0040] If the difference measure exceeds the allowed range, re-enter the actual model requirement parameters into the large language model;

[0041] Update the proxy model structure description parameters and the proxy model source code text;

[0042] Recompile to generate a new executable agent model.

[0043] Preferably, the method further includes storing the constructed executable agent model, the stored procedure including:

[0044] Save the executable agent model to the model repository;

[0045] A unique identifier is generated based on the set of input condition parameters, which is used for indexing and retrieving proxy models.

[0046] Compared with the prior art, the beneficial effects of the present invention are:

[0047] By analyzing CFD input conditions and dynamically predicting model requirements using a large language model, the traditional method of manually selecting models and presetting parameters based on expert experience is replaced. The large language model can understand complex semantic relationships and physical constraints of parameters, enabling the requirement analysis of the surrogate model to move beyond fixed rules and instead rely on deep reasoning about specific simulation scenarios. This understanding-based dynamic prediction capability allows the surrogate model to be better aligned with the simulation objectives from the outset, avoiding accuracy loss or wasted computational resources due to model architecture mismatch, and achieving intelligent and adaptive optimization in the model design process.

[0048] By leveraging a large language model to extract features from real-time flow field data sequences generated during simulation, more accurate parameters required by the actual model are obtained. Unlike fixed feature extraction algorithms such as PCA, the large language model can identify key features and patterns crucial to the dynamic evolution of the current flow field by incorporating the physical context of the simulation. This ensures that the constructed surrogate model focuses on the most relevant physical phenomena, enhancing its ability to capture complex flow details. Consequently, while reducing input dimensionality, this approach strengthens the surrogate model's expressive power and predictive accuracy.

[0049] By directly generating structural description parameters and executable source code text for proxy models using a large language model, the method achieves automatic conversion from requirements to code. This approach eliminates the traditional process of manually writing and debugging model code, freeing developers from tedious programming tasks. The large language model can generate optimally structured and syntactically correct source code based on immediately defined requirements, shortening the proxy model development cycle, lowering the technical threshold, ensuring consistency between code implementation and design intent, reducing errors that may be introduced by manual coding, and making it possible to quickly build high-quality, customized proxy models for specific scenarios. Attached Figure Description

[0050] Figure 1 This is a schematic diagram illustrating the working principle of the dynamic construction method for CFD simulation proxy models based on large language models described in this invention.

[0051] Figure 2 A flowchart for generating demand forecasting parameters for the proxy model;

[0052] Figure 3 A flowchart illustrating how to extract features from a large language model to obtain the parameters required for the actual model;

[0053] Figure 4 A graph showing the trend of the loss function during the training process of the surrogate model;

[0054] Figure 5 A comparative analysis chart of relative errors for surrogate model validation cases. Detailed Implementation

[0055] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. 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.

[0056] Please see Figure 1 This invention provides a method for dynamically constructing a proxy model for CFD simulation based on a large language model. The method includes: inputting a set of input condition parameters into a pre-trained large language model; the large language model outputs a proxy model type prediction result as a proxy model requirement prediction parameter. Based on the proxy model requirement prediction parameter, a flow field data sequence is collected during the CFD simulation process, including starting the CFD simulation and running the simulation case. During simulation iterations, the numerical distribution of flow field variables, such as velocity, pressure, and temperature distributions, is recorded periodically, and the recorded numerical distributions are arranged chronologically to form a flow field data sequence. Features are extracted from the flow field data sequence using the large language model to obtain actual model requirement parameters. This step utilizes the feature recognition module in the large language model to perform data pattern analysis and key feature identification. The actual model requirement parameters are processed by the large language model to dynamically generate proxy model structure description parameters. The large language model generates a network architecture description of the proxy model based on the actual model requirement parameters and parses this description to obtain the proxy model structure description parameters. Based on the proxy model structure description parameters, the large language model generates proxy model source code text. The large language model generates code content including model layer definitions, loss functions, and training algorithms based on the structure description parameters. The proxy model source code text is converted into an executable proxy model. The source code text is compiled using a code compiler, the runtime library files are linked to generate an executable code file, and the correctness of the executable code file is checked to complete the proxy model construction.

[0057] Example 1: See Figure 2In practical implementation, the analysis process based on the large language model involves obtaining geometric parameters, boundary condition parameters, and material property parameters from computational fluid dynamics simulation cases. Geometric parameters include the size and shape information of the computational domain; boundary condition parameters include inlet velocity conditions, outlet pressure conditions, and wall boundary types; and material property parameters include fluid density and dynamic viscosity values. These parameters are combined into a structured set of input condition parameters. In practice, the input condition parameter set is input into a pre-trained large language model in the form of text or numerical vectors. The large language model is trained based on historical computational fluid dynamics simulation data and can process the input condition parameter set and output surrogate model type prediction results. These surrogate model type prediction results are used as surrogate model demand prediction parameters. In some embodiments, the format of the input condition parameter set may include key-value pairs or structured query language records to ensure that the large language model can accurately parse parameter relationships. The computational fluid dynamics simulation is started, and the simulation case is run. The simulation case initializes the solver settings based on the input condition parameter set. During the simulation iteration process, the numerical distribution of flow field variables is recorded periodically. The recording interval is determined based on the simulation time step or the number of iterations. The numerical distribution of flow field variables includes the values ​​of velocity, pressure, and temperature at the grid points. This recording process is implemented through the output module of the simulation software, saving the flow field data from each iteration as a data file. In some embodiments, the recording frequency can be adjusted according to simulation stability, for example, recording the numerical distribution once every 100 iterations. The recorded numerical distributions are arranged in chronological order to form a flow field data sequence, which is represented as a time-indexed dataset. Optionally, the flow field data sequence can be stored as a multidimensional array or a time-series database format. In a specific implementation, the structure of the flow field data sequence is defined by the following formula:

[0058] ;

[0059] in: Represents the flow field data sequence. Indicates time Recorded flow field snapshots This represents the total number of records, for each flow field snapshot. This includes velocity distribution vectors, pressure distribution vectors, and temperature distribution vectors. It can be understood that the flow field data sequence is used in subsequent feature extraction steps to ensure temporal consistency of the data. Optionally, the storage format of the flow field data sequence can be HDF5 or NetCDF to support efficient read and write operations. In specific implementations, when the large language model processes the set of input conditional parameters, the surrogate model type prediction result may include neural network architecture type or regression model type, depending on the complexity of the set of input conditional parameters.

[0060] Example 2: See Figure 3 In specific implementations, the selection of the feature recognition module is based on the surrogate model's demand prediction parameters. These parameters indicate the required type of feature analysis; for example, when the surrogate model's demand prediction parameters point to spatial feature extraction, the spatial feature recognition module is selected; when they point to temporal feature extraction, the temporal feature recognition module is selected. In specific implementations, the flow field data sequence is input to the selected feature recognition module. The feature recognition module performs data pattern analysis on the input flow field data sequence. This data pattern analysis process identifies the distribution patterns of flow field variables in the spatial dimension and their evolution trends in the temporal dimension. Simultaneously, the feature recognition module performs key feature recognition, focusing on identifying physical feature patterns that have a decisive impact on flow behavior. It can be understood that data pattern analysis may include gradient distribution analysis of the velocity field or extreme point detection of the pressure field, while key feature recognition may include the identification of the core region of the vortex structure or the extraction of boundary layer velocity profiles. In some embodiments, the feature recognition module employs an attention-based neural network structure to process the flow field data sequence, with attention weights used to highlight salient regions in the flow field data sequence. The feature recognition results are output as parameters required by the actual model. These parameters describe the identified feature types, spatial locations, and intensity indices in a structured data format. In practice, the mathematical expression of the feature extraction process can be described by the following formula:

[0061] ;

[0062] in: This represents the feature recognition result vector. This represents the activation function. Represents the weight matrix. Represents the flow field data sequence Preprocessing transformation, This represents the bias vector. Actual model requirements include the feature recognition result vector as a parameter. The encoding information is used. Optionally, the feature recognition module can be configured with different convolutional kernel sizes to adapt to the recognition of flow field structures at different scales. In a specific implementation, the actual model requirement parameters are input into the structure generation module of the large language model. The structure generation module parses the feature type and complexity information contained in the actual model requirement parameters. The structure generation module generates a network architecture description of the surrogate model based on the actual model requirement parameters. The network architecture description specifies the type of neural network layers, the connection order of the layers, the number of neurons in each layer, and the activation function type in text form. In some embodiments, when the actual model requirement parameters indicate the existence of multi-scale spatial features, the network architecture description may include skip connections or encoder-decoder structures. The surrogate model structure description parameters are obtained by parsing the network architecture description. The parsing process converts the text-based network architecture description into a machine-readable set of structured parameters. The surrogate model structure description parameters explicitly record the network depth, inter-layer connection relationships, and parameter initialization methods. Optionally, the parsing of the network architecture description can be achieved using a parser or regular expression matching. It can be understood that the surrogate model structure description parameters provide an accurate model blueprint for subsequent source code generation, ensuring that the model structure matches the flow field features.

[0063] Example 3: In a specific implementation, the large language model receives proxy model structure description parameters as input. These parameters define the number of neural network layers, the number of neurons in each layer, inter-layer connections, and activation function types in a structured data format. Based on these parameters, the large language model generates complete machine learning model code. In this implementation, the generated code includes model layer definitions, which detail the type, input dimension, output dimension, and parameter initialization method for each neural network layer. The code also includes a loss function definition, specifying the optimization objective and error calculation method. Furthermore, the code includes a training algorithm, which describes the update rules for model parameters and the learning rate scheduling strategy. In some embodiments, the model layer definition may include instantiation code for convolutional layers, fully connected layers, or recurrent neural network layers. The loss function may be defined as mean squared error or a custom physical information constraint loss. The training algorithm may implement stochastic gradient descent. When the training algorithm implements stochastic gradient descent, the proxy model source code text generated by the large language model includes corresponding optimizer instantiation code. This code defines the parameter update rules and learning rate scheduling strategy to ensure efficient convergence of the model training process. The specific implementation of the stochastic gradient descent algorithm involves processing flow field data batch by batch during the training loop, calculating the gradient of the loss function with respect to the model parameters, and updating the weight values ​​based on the gradient direction to minimize the prediction error. This implementation aligns with the needs of dynamically constructing surrogate models, balancing training speed and stability through adaptive adjustment of the learning rate, enabling the generated surrogate model to quickly adapt to changes in flow field characteristics during CFD simulations. The large language model outputs the generated surrogate model source code text, which is a plain text file conforming to the syntax specifications of a specific programming language, containing complete class definitions, function implementations, and dependency library declarations.

[0064] In practical implementation, a code compiler is used to compile the proxy model source code text. The code compiler parses the syntax structure and data types in the proxy model source code text, converting high-level language code into intermediate representation or target machine code. The compilation process includes lexical analysis, syntax analysis, semantic analysis, and code optimization stages. Linking runtime library files generates executable code files. The linker parses external symbol references in the proxy model source code text, performs address relocation and symbol resolution on the compiled target code and necessary runtime library files, generating independent executable code files. It is understood that the code compiler can choose the GCC or Clang open-source compilation toolchain, and the runtime library files include mathematical operation libraries and neural network inference libraries. Checking the correctness of the executable code file involves verifying the integrity of the file format and dependencies. The verification process is implemented through file checksums and dynamic linking tests. Optionally, correctness checks may include running simple test cases to verify whether the input and output behavior meets expectations. An executable proxy model is output, which is a binary file or bytecode file that can be loaded and executed in the target computing environment. In some embodiments, the compilation process can be configured with different optimization levels, such as using the -O2 optimization option to balance execution efficiency and compilation time. The process of generating an executable agent model can be described by the following formula to ensure completeness:

[0065] ;

[0066] in: This indicates an executable proxy model. Indicates a link operation. Indicates a compiled function. This represents the source code text of the proxy model. This indicates compiler configuration parameters. This represents the collection of runtime library files. It can be understood that the executable agent model encapsulates the complete model structure and inference logic, enabling it to run independently of the development environment. Optionally, the executable code file format can be either ELF or PE to suit the requirements of different operating system environments.

[0067] See Figure 4 The diagram illustrates the changes in the loss function of the surrogate model during training, including two curves: training loss and validation loss. The training loss reflects the model's fit to the training dataset, while the validation loss reflects its generalization ability on unseen data. As the number of training epochs increases, both loss curves show a decreasing trend, indicating that the model parameters are continuously optimized and that it has learned effective feature representations of the flow field data. The stable convergence of the loss function proves that the generated surrogate model source code can effectively implement the neural network training algorithm, has a reasonable model structure design, and possesses good learning ability and prediction accuracy.

[0068] Example 4: In a specific implementation, the executable surrogate model is run on a validation case to obtain surrogate model output data. The validation case includes boundary conditions and initial conditions that are different from the training data but have similar physical backgrounds. The surrogate model output data includes the predicted distribution of flow field variables. The surrogate model output data is compared with the standard computational fluid dynamics simulation output data. The standard computational fluid dynamics simulation output data comes from high-fidelity simulation results that have undergone mesh independence verification and time step verification. The comparison process involves numerical comparison of corresponding physical quantities at the same spatial location and time step. A multi-index evaluation method is used to calculate the difference metric. The difference metric reflects the degree of deviation between the surrogate model's prediction results and the reference solution. The difference metric value is quantified through mathematical operations. In a specific implementation, the difference metric calculation can be expressed by the following formula:

[0069] ;

[0070] in: This represents a measure of relative error difference. Indicates the total number of data points. This indicates the output data of the proxy model. This represents the output data of a standard computational fluid dynamics simulation. This represents a small constant to prevent division by zero. The suitability of the surrogate model is determined based on the difference metric. The determination process compares the calculated difference metric value with a preset threshold. If the difference metric value is lower than the preset threshold, the surrogate model is considered acceptable; if the difference metric value is higher than the preset threshold, the surrogate model is considered unacceptable. In some embodiments, the difference metric may simultaneously include multiple evaluation indicators such as mean absolute error and coefficient of determination, as shown in Table 1.

[0071] Table 1: Evaluation Table for Validation Case Difference Measurement

[0072] ;

[0073] If the difference metric exceeds the allowable range, the actual model requirement parameters are re-entered into the large language model. These parameters include feature recognition result vectors and feature type description information. The proxy model structure description parameters and the proxy model source code text are updated. The update process involves re-analyzing and generating code based on the newly input actual model requirement parameters from the large language model. It is understood that updating the proxy model structure description parameters may involve increasing the number of neural network layers or adjusting the number of neurons, while updating the proxy model source code text reflects the model implementation after structural adjustments. A new executable proxy model is recompiled, using the same code compiler and runtime library file configuration to ensure consistency of the compilation environment. In some embodiments, the allowable range can be set with different thresholds for different flow field variables; for example, the allowable range for the velocity field is set to 0.05, and the allowable range for the pressure field is set to 0.08. Optionally, when re-entering the actual model requirement parameters, feature dimensions can be increased or feature extraction strategies modified to improve the proxy model's ability to capture complex flow field features. During the update of the proxy model structure description parameters, the large language model can adjust the regularization method in the network architecture description based on previous validation results. The specific implementation of the regularization method involves the large language model re-evaluating the feature complexity information in the actual model requirements parameters when the difference metric exceeds the allowable range, and accordingly modifying the regularization clauses in the network architecture description, such as adjusting the weight decay coefficient or adding dropout layer settings, to ensure that the surrogate model reduces its over-reliance on training data while maintaining prediction accuracy. After recompiling to generate a new executable surrogate model, the verification testing process needs to be re-executed, forming an iterative optimization loop. It is understood that the recompilation process may require adjusting compiler optimization options to adapt to the updated surrogate model source code text structure. Optionally, when the difference metric exceeds the allowable range, the feature recognition module can be reconfigured to extract more refined flow field features. In practice, an upper limit can be set for the number of iterations for adjusting surrogate model parameters to avoid infinite loops consuming computational resources.

[0074] See Figure 5 This paper presents a comparison of the relative errors between the surrogate model predictions and standard CFD simulation data in different validation cases. Each bar chart represents the error metric for an independent validation case, with the orange dashed line indicating a preset acceptable threshold. Cases below the threshold indicate that the surrogate model's prediction accuracy meets the requirements and can accurately capture the physical characteristics of the flow field; cases above the threshold require further optimization of the model structure or adjustment of parameters. This multi-case validation method ensures the robustness of the surrogate model under different boundary and initial conditions, providing a quantitative evaluation basis for the reliability of the model in practical engineering applications.

[0075] Example 5: In a specific implementation, the executable proxy model is saved to a model repository. The model repository is a system used to store and manage proxy model files. It employs a version control mechanism to manage different versions of the executable proxy model files. The saving process involves transferring the executable proxy model file to the storage medium of the model repository and recording model metadata. In this implementation, the model metadata includes the creation time of the executable proxy model, the hash value of the input condition parameter set, and model performance metrics. The model repository allocates independent storage space and access paths for each executable proxy model. A unique identifier is generated based on the input condition parameter set. The generation process uses a cryptographic hash function to process the serialized byte stream of the input condition parameter set, which contains structured data of geometric parameters, boundary condition parameters, and material property parameters. The unique identifier is used to index and retrieve proxy models. The indexing mechanism establishes a mapping relationship between the unique identifier and the storage path of the executable proxy model. The retrieval operation locates the corresponding executable proxy model file by querying the unique identifier. In this implementation, the unique identifier generation process is implemented using the following formula:

[0076] ;

[0077] in: Indicates the generated unique identifier, This represents hash function operations. This represents the serialization process of the input condition parameter set. Represents geometric parameters, Represents boundary condition parameters. This represents material property parameters. It's understood that the hash function can choose the SHA-256 algorithm to ensure the uniqueness of the identifier, and the serialization process can use JSON or Protocol Buffers format. In specific implementations, the SHA-256 algorithm involves using a serialized byte stream of the input condition parameter set as input. This set contains structured data of geometric parameters, boundary condition parameters, and material property parameters. The serialization process uses JSON or Protocol Buffers format to convert the parameters into a standard byte stream. The SHA-256 algorithm performs a hash operation on this byte stream to generate a 256-bit fixed-length hash value. This hash value serves as a unique identifier for the model repository's indexing mechanism. The collision resistance of the SHA-256 algorithm ensures that the probability of different input condition parameter sets generating the same hash value is extremely low, thereby guaranteeing the accuracy and uniqueness of proxy model retrieval. In some embodiments, the model repository can be implemented as a distributed file system or relational database, supporting high-concurrency access and data redundancy backup. The correspondence between unique identifiers and executable proxy models is recorded in the model repository's index table. The index table maintains a mapping record of identifier hash values, model storage paths, and creation timestamps. Optionally, the model repository can set access control policies to restrict read and write permissions for specific executable proxy models. When indexing and retrieving proxy models, the system calculates the hash value of the input condition parameter set and matches it in the index table to locate the corresponding executable proxy model storage path. It is understood that the generation of unique identifiers needs to ensure that the same set of input condition parameters always produces the same hash value, and the probability of different sets of input condition parameters producing conflicting hash values ​​is extremely low. In some embodiments, the model repository can be configured with an automatic cleanup mechanism to remove expired model files based on the usage frequency and storage time of the executable proxy models. Optionally, the model repository can provide an application programming interface (API) to support batch retrieval of multiple executable proxy model files using unique identifiers.

[0078] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A method for dynamically constructing a CFD simulation proxy model based on a large language model, characterized in that, The method includes: Based on the analysis of the input condition parameter set of CFD simulation using a large language model, the output surrogate model type prediction result is used as the surrogate model demand prediction parameter. Based on the surrogate model requirement prediction parameters, flow field data sequences during CFD simulation are collected, and features are extracted from the flow field data sequences using a large language model. The feature recognition results are output as actual model requirement parameters. The actual model requirement parameters describe the identified feature types, feature spatial locations, and feature intensity indices in a structured data format. The actual model requirement parameters are processed by a large language model to dynamically generate proxy model structure description parameters. Based on the proxy model structure description parameters, the proxy model source code text is generated using a large language model. The source code text of the proxy model is converted into an executable proxy model, thus completing the proxy model construction.

2. The method for dynamically constructing a CFD simulation proxy model based on a large language model as described in claim 1, characterized in that, The set of input condition parameters for analyzing CFD simulations based on large language models generates surrogate model demand prediction parameters, including: Obtain the geometric parameters, boundary condition parameters, and material property parameters of the CFD simulation case, and combine them to form a set of input condition parameters; The set of input condition parameters is input into a pre-trained large language model, which is trained based on historical CFD simulation data.

3. The method for dynamically constructing a CFD simulation proxy model based on a large language model as described in claim 1, characterized in that, The step of collecting flow field data sequences during CFD simulation based on the surrogate model's demand prediction parameters includes: Start the CFD simulation and run the simulation case; During the simulation iteration process, the numerical distribution of flow field variables, including velocity distribution, pressure distribution, and temperature distribution, are recorded periodically. The numerical distributions recorded multiple times are arranged in chronological order to form a flow field data sequence.

4. The method for dynamically constructing a CFD simulation proxy model based on a large language model as described in claim 1, characterized in that, The step of using a large language model to extract features from the flow field data sequence to obtain the parameters required for the actual model includes: Based on the demand prediction parameters of the agent model, select the feature recognition module in the large language model; The flow field data sequence is input into the feature recognition module for data pattern analysis and key feature recognition. The output feature recognition results are used as parameters required by the actual model.

5. The method for dynamically constructing a CFD simulation proxy model based on a large language model as described in claim 1, characterized in that, The process of processing the actual model requirement parameters through a large language model to dynamically generate proxy model structure description parameters includes: Input the actual model requirement parameters into the structure generation module of the large language model; The large language model generates a network architecture description of the proxy model based on the actual model requirement parameters; The network architecture description is parsed to obtain the proxy model structure description parameters.

6. The method for dynamically constructing a CFD simulation proxy model based on a large language model as described in claim 1, characterized in that, The step of generating proxy model source code text using a large language model based on the proxy model structure description parameters includes: The large language model generates the code content of the machine learning model based on the parameters described by the agent model structure. The code content includes model layer definitions, loss functions, and training algorithms; Output the generated proxy model source code text.

7. The method for dynamically constructing a CFD simulation proxy model based on a large language model as described in claim 1, characterized in that, The step of converting the proxy model source code text into an executable proxy model includes: The source code text of the proxy model is compiled using a code compiler; Link runtime library files to generate executable code files; Check the correctness of the executable code file and output the executable proxy model.

8. The method for dynamically constructing a CFD simulation proxy model based on a large language model as described in claim 1, characterized in that, The process also includes performing verification tests on the executable proxy model to obtain a verified proxy model, wherein the verification tests include: Run the executable proxy model in the validation case and obtain the proxy model output data; Compare the output data of the proxy model with the output data of the standard CFD simulation, and calculate the difference metric. The suitability of a proxy model is determined based on the difference metric.

9. The method for dynamically constructing a CFD simulation proxy model based on a large language model as described in claim 8, characterized in that, After determining whether the proxy model is qualified based on the difference metric, the process also includes adjusting the proxy model parameters, which includes: If the difference measure exceeds the allowed range, re-enter the actual model requirement parameters into the large language model; Update the proxy model structure description parameters and the proxy model source code text; Recompile to generate a new executable agent model.

10. The method for dynamically constructing a CFD simulation proxy model based on a large language model as described in claim 1, characterized in that, It also includes the completed executable agent model for storage, and the stored procedures include: Save the executable agent model to the model repository; A unique identifier is generated based on the set of input condition parameters, which is used for indexing and retrieving proxy models.

Images