A Designable Data Augmentation Meta-Modeling Method

Abstract

This application relates to the field of engineering simulation and data-driven modeling technology, specifically, to a designable data-augmented meta-modeling method. The method includes: acquiring real design variables and real performance responses of mature products, and inputting candidate design variables proposed for the product to be designed into a simulation model for calculation to obtain target design variables and target performance responses; building a designable generative model and training the designable generative model; forward propagating to a generator to obtain multiple virtual performance responses, inputting each virtual performance response into an inverse generator to obtain the mean and variance of each design variable; constructing confidence intervals for the design variables based on the mean and log-variance of each design variable, thereby obtaining virtual design variables. This application generates virtual samples conforming to physical laws through a designable generative model, inversely infers design parameters, and provides a method for estimating uncertainty.

Description

Technical Field

[0001] This application relates to the field of engineering simulation and data-driven modeling technology, and more specifically, to a designable data-enhanced meta-modeling method. Background Technology

[0002] In the design of complex engineering products, it is often necessary to establish a meta-model between design variables (such as thickness and strength) and performance responses (such as force versus displacement curves) to replace costly finite element or CFD simulations. Traditional response surface methodology and neural network methods rely on a large number of uniform samples, but obtaining samples in engineering is costly and time-consuming.

[0003] To alleviate the small sample size problem, existing studies have introduced data augmentation techniques such as generative adversarial networks and variational autoencoders. These techniques can only generate virtual responses in a forward manner, but cannot solve the inverse design problem of "which design variables can produce a certain response".

[0004] In recent years, designable data augmentation methods for domain knowledge integration have attempted to incorporate inverse generators, but three obvious drawbacks remain: 1) Inverse generators only output deterministic values ​​of design variables, lack uncertainty quantification, and cannot assess risks, which is unacceptable, especially in high-reliability domains; 2) Physical constraints use fixed thresholds, which are either too tight, resulting in insufficient diversity, or too loose, resulting in a lack of rationality and difficulty in adapting to different data distributions; 3) Inconsistencies exist between generation and inversion, and the design variables obtained by inversion from virtual responses cannot reproduce the original responses, leading to self-contradictory models.

[0005] Therefore, there is an urgent need for a new modeling method that can simultaneously quantify uncertainty, adapt to physical constraints, and ensure consistency between generation and inference. Summary of the Invention

[0006] The purpose of this application is to provide a designable data augmentation meta-modeling method that generates virtual samples that conform to physical laws through a designable generative model, reverse-engineers design parameters, and provides a method for estimating uncertainties. It can be applied to industrial scenarios such as automotive collision simulation, aerospace structural component optimization, battery thermal management, and mechanical system reliability analysis, where surrogate models can be quickly constructed using a small amount of high-fidelity simulation data.

[0007] To achieve the above objectives, this application provides a data augmentation meta-modeling method that can be designed, including: Obtain the real design variables and real performance response of mature products, and input the candidate design variables proposed for the product to be designed into the simulation model for calculation to obtain the target design variables and target performance response; Build a designable generative model, including: generator, inverse generator, physical regularizer, discriminator and forward mapping network; The designable generative model is trained; Multiple noise vectors are sampled from a standard normal distribution and forward-propagated to a generator to obtain multiple virtual performance responses. Each virtual performance response is then input into the inverse generator to obtain the mean and variance of each design variable. Confidence intervals for each design variable are constructed based on its mean and logarithmic variance, thus obtaining the virtual design variables.

[0008] Compared with the prior art, this application has the following beneficial effects: This application provides a designable data augmentation meta-modeling method that ensures consistency between generation and back-inference: under conditions of data scarcity, it generates physically more reasonable and more diverse virtual engineering data; when performing back-inference of design variables, it not only provides point estimates but also outputs uncertainty intervals representing prediction confidence, thereby supporting risk-assessable design decisions; at the same time, it ensures a high degree of mutual inverse consistency between the generated virtual data and the back-inferred design variables, improving the reliability of the overall model; and thus provides an efficient, reliable, and transparent data-driven design tool that significantly shortens product development cycles and improves design quality. Attached Figure Description

[0009] To more clearly illustrate the technical solutions in the specific embodiments of this application or the prior art, the drawings used in the description of the specific embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0010] Figure 1 This is a flowchart illustrating a data augmentation meta-modeling method that can be designed according to an embodiment of this application; Figure 2 This is a schematic diagram of the structure of the inverse generator provided in the embodiments of this application. Detailed Implementation

[0011] The following description, in conjunction with the accompanying drawings, illustrates exemplary embodiments of this application, including various details to aid understanding. These should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of this application. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0012] Figure 1 This embodiment provides a data augmentation meta-modeling method that can be designed. See [link to relevant documentation]. Figure 1 The method provided in this embodiment includes: S110. Obtain the actual design variables and actual performance response of the mature product, and input the candidate design variables proposed for the product to be designed into the simulation model for calculation to obtain the target design variables and target performance response.

[0013] Mature products include, for example, mature vehicles / bumpers. In the specific scenario of automotive crash simulation, design variables include structural and material parameters that can be directly modified in the finite element model, such as the thickness of the B-pillar inner panel, the thickness of the front longitudinal beam outer panel, the thickness of the sill beam reinforcement plate, and the yield strength of the A-pillar material. The performance response is a curve showing the change of collision force with displacement at 200 discrete points, with each point corresponding to the barrier reaction force under a certain compressive displacement. Together, these constitute the input-output engineering data pair used to build a designable generative model.

[0014] Two types of data are collected: source domain data and target domain data. Source domain data comes from mature products with similar physical principles to the product under design and a large amount of existing simulation or experimental data, such as 185 sets of collision simulation results for a car body, each set containing the actual design variable x and the actual performance response y. Target domain data (less than 100 sets) consists of candidate design variables (e.g., using a rigid structure) proposed for the product under design and input into the simulation model for calculation. The data is cleaned, removing non-convergent or outlier samples, and all target design variables and target performance responses are normalized to the interval [-1,1] or [0,1]. During normalization, the source domain and target domain independently calculate their respective means and standard deviations (or maximum and minimum values). However, before inputting the target domain data into the network during subsequent model training, the source domain normalization parameters must be used to transform the target domain data to ensure distribution alignment (e.g., Gaussian distribution).

[0015] S120. Build a designable generative model, including: generator, inverse generator, physical regularizer, discriminator and forward mapping network.

[0016] The generative model can be designed to include the following sub-networks: generator G, inverse generator IG, learnable physical regularizer R, discriminator D, and forward mapping network F. The core functions and network structures of each sub-network are as follows: The generator G takes a random noise vector z as input, for example, sampled from a standard normal distribution with a dimension of 100 and no physical meaning; the output is a virtual performance response. This virtual performance response is used to augment small sample datasets. The format is the same as the actual performance response y and the target performance response.

[0017] ; Where z is a random noise vector, θ GThis represents all trainable parameters of the generator G (such as the weight matrix and bias terms in the network), which are continuously updated during training by an optimization algorithm to enable the generator G to fit the distribution of real engineering data.

[0018] The generator G's structure includes: a fully connected layer, multiple transposed convolutional blocks, an adaptive average pooling layer, and a flattening layer. Taking the design variables, including vehicle parameters affecting vehicle collision performance in a car crash simulation scenario, and the performance response, including the sequence of collision force changes with displacement, as an example, the random noise vector z is mapped to... 4096 After being reshaped into a 64×64 feature map, it is then passed sequentially through four transposed convolutional blocks. Each transposed convolutional block contains a transposed convolutional layer (4×4 kernel size, stride 2, padding 1), a batch normalization layer, and a ReLU activation function. The number of output channels for the four transposed convolutional blocks are 128, 64, 32, and 1, respectively. Then, the output of the fourth transposed convolutional block is fed to an adaptive average pooling layer (which automatically calculates the kernel size and stride based on the input size) to compress the features to the specified dimension. Finally, a flattening layer generates a vector of length 200, which is a virtual performance response in the form of a force-displacement curve. .

[0019] The input to the inverse generator IG is the virtual performance response. Or, unlike existing designable data augmentation methods, IG does not directly output a single value of the design variable, but instead outputs the probability distribution parameters of the design variable (e.g., estimated parameters of a Gaussian distribution), including the mean and log-variance, thereby enabling inverse inference with uncertainty quantification. ; Where, θ IG These are all the trainable parameters of the inverse generator. This is an estimate of the mean of the design variables (for example, when d=4, it corresponds to the predicted values ​​of the front longitudinal beam thickness, B-pillar thickness, sill thickness, and A-pillar yield strength, respectively). The output uses log-variance for each dimension. The reason for using log-variance is that the variance must be positive, and the logarithmic transformation can automatically map unconstrained regression values ​​to positive variance (this technique is cited from Kingma & Welling, "Auto-Encoding Variational Bayes", 2014).

[0020] Figure 2This is a schematic diagram of the inverse generator provided in an embodiment of this application. The inverse generator includes a convolutional feature extractor, a mean header, and a variance header. The convolutional feature extractor comprises 5 one-dimensional convolutional layers with output channels of 64, 128, 256, and 512, a kernel of 5, a stride of 2, followed by a global average pooling layer. The mean header and variance header are connected in parallel after the global average pooling layer. The mean header uses linear activation to obtain a mean estimate, and the variance header uses linear and exponential operations to obtain the logarithmic variance.

[0021] Output logarithmic variance Then, calculate the actual variance. with standard deviation : ; ; For the design variable of the j-th dimension, its estimation follows , Input virtual performance response At that time, the mean and variance of the j-th dimension design variable output by IG follow a Gaussian distribution with diagonal covariance. When the model considers the design variables derived from the collision curve to be uncertain, the variance will be large, indicating that the inference is unreliable and should be used with caution.

[0022] The input to the physical regularizer R is the virtual performance response. The intermediate features output from the third transposed convolutional block in generator G, along with the 32-channel feature map output from the third transposed convolutional block, serve as direct material for generating the final curve and also preserve the multi-scale semantic information of the generation process. The physical regularizer R outputs a scalar score, quantitatively evaluating the degree to which the virtual performance response violates physical laws, acting as an adaptive physical constraint. A higher s value indicates greater unreasonableness. ; Where, θ R For all trainable parameters of the physical regularizer R, s is an intermediate feature, and s is a scalar score output by the physical regularizer R. The physical regularizer R uses a neural network structure, such as a convolutional neural network.

[0023] The input to discriminator D is the virtual performance response. Alternatively, the true performance response y can be used to output a discriminant score. A generative model can be designed using a generative adversarial training framework. The core role of the discriminator D is to distinguish between the true performance response and the virtual performance response generated by the generator G, thereby providing adversarial supervision signals to the generator G and prompting it to output samples that more closely approximate the real data distribution.

[0024] To improve training stability and avoid the mode collapse and gradient vanishing problems common in traditional GANs, the discriminator D in this invention adopts the WGAN-GP form (cited from Gularajani et al., “Improved Training of Wasserstein GANs”, NIPS 2017). The specific network structure includes: an input layer (a single-channel performance response signal with a length of 200), a first convolutional layer (one-dimensional convolution, 1 input channel, 64 output channels, kernel size 5, stride 2, padding 2), a LeakyReLU activation function (negative slope 0.2), a second convolutional layer (64 input channels, 128 output channels, kernel size 5, stride 2, padding 2), normalization and LeakyReLU activation function, a third convolutional layer (128 input channels, 256 output channels, kernel size 5, stride 2, padding 2), normalization and LeakyReLU activation function, a fourth convolutional layer (256 input channels, 512 output channels, kernel size 5, stride 2, padding 2), normalization and LeakyReLU activation function, and a fifth convolutional layer (512 input channels, 1 output channel, kernel size 4, stride 1, padding 0), ultimately outputting a discriminant score. Optionally, the fifth convolutional layer can be replaced with adaptive global average pooling followed by a fully connected layer. Under the WGAN framework, the discriminant score has no upper bound; the larger the value, the more likely the input sample is to be a true performance response.

[0025] The input to the forward mapping network F is the mean of the design variables output by the real design variables or the inverse generator IG. The output is a predicted performance response, with the same data format as y (e.g., a force-displacement curve of length 200). Optionally, the structure of the forward mapping network F includes: a fully connected layer, a feature transformation layer, and multiple transposed convolutional blocks connected in sequence (see the structure of generator G); each transposed convolutional block includes a transposed convolutional layer, a batch normalization layer, and a ReLU activation function. Specifically, in this embodiment, the input design variables are mapped to a high dimension through the fully connected layer, and then the curve is generated through the feature transformation layer and multiple transposed convolutional blocks. F uses a 3-layer fully connected network (input layer dimension d=4, hidden layers 128 and 256, output layer 200), with ReLU activation function, and the output layer has no activation, performing direct regression.

[0026] S130. Train the designable generative model.

[0027] This embodiment adopts a three-stage training approach: pre-training, joint training, and end-to-end fine-tuning, which will be described in detail below.

[0028] 1) Pre-training phase: Pre-trained Inverse Generator (IG): The target performance response is used as input samples, and the mean of the target design variable is used as labels to train the convolutional feature extractor and mean head of the inverse generator (IG). The loss function is chosen to be the mean head output combined with the mean squared error loss of the labels.

[0029] Pre-trained physical regularizer R: To avoid the problems of poor adaptability and difficulty in matching different data distributions caused by manually setting fixed thresholds in traditional methods (e.g., requiring the energy residual to be absolutely less than 20%), this embodiment proposes a data-driven pre-training strategy that enables R to automatically learn the boundary between "reasonable" and "unreasonable" from a statistical perspective. Real performance responses are used as reasonable samples, and physical residuals are calculated based on energy conservation and mapped to violation score labels. Perturbations are applied to real performance responses to create unreasonable samples, and physical residuals are calculated based on energy conservation and mapped to violation score labels. The physical regularizer R is trained using the reasonable samples, unreasonable samples, intermediate features output from the third transposed convolutional block in the generator G, and the corresponding violation score labels.

[0030] In vehicle collision scenarios, calculable physical laws are extracted from mechanical principles, such as energy conservation during the collision process. Integrating the impact load over the vehicle displacement yields the work done by the external force (i.e., the total work done by the external force on the structure); integrating the collision force over the displacement yields the increase in the internal energy of the structure (i.e., the energy absorbed by the structural deformation); the absolute difference between the work done by the external force and the increase in the internal energy of the structure is taken as the physical residual r(y,x). r(y,x)=|W ext (x) U(y)|; Where x is the actual design variable, y is the actual performance response, and U(y) is the structural internal energy increment, a function of the actual performance response y; W ext (x) represents the work done by external forces, a function of the actual design variable x; the physical residual should theoretically approach 0, and the work done by external forces equals the increase in the internal energy of the structure; non-zero values ​​reflect the degree of violation of energy conservation. The significance of the absolute value operation is to make the residual non-negative, which is convenient for subsequent use as a penalty term for physical constraints. This residual will be used as the input for subsequent adaptive constraints.

[0031] Since reasonable samples are directly taken from existing high-fidelity simulation data, their violation score labels are artificially set to a regression baseline value of 0, representing the 'no violation' category, rather than claiming that their physical residuals are absolutely zero; the residual distribution of the actual reasonable samples is used to calculate the average residual as a statistical benchmark. Unreasonable samples are constructed by applying controlled perturbations to the true performance response curve. For example, the true performance response y (using a scaling factor) is randomly scaled and its sign reversed (e.g., taking +1 with a 50% probability and -1 with a 50% probability), thus severely violating energy conservation. This embodiment does not limit the specific form of the perturbation, as long as the residual r after perturbation is greater than or equal to twice the average residual of reasonable samples. This ensures that the violation level of each unreasonable sample significantly exceeds the typical reasonable level. For unreasonable samples, the physical residuals are mapped to violation score labels using the following preset mapping formula: s label =0.5+0.5×(r'-2μ r ) / (r max -2μ r ); Among them, s label Let r' be the label for the violation score, r' be the residual of the sample after applying the perturbation, and μ be the value of μ. r For the average residual of a reasonable sample, r max This is a preset upper limit for residuals. Exceeding r... max The value is then truncated to 1.0. Therefore, the labels of unreasonable samples are distributed in the interval [0.5, 1.0], and the larger the residual, the higher the score.

[0032] The pre-training dataset for the physical regularizer R consists of thousands of reasonable samples (label 0) and an equal number of unreasonable samples (labels 0.5–1.0). The input to R is a pair of [performance response, intermediate features]. The intermediate features of reasonable samples are obtained by inputting a standard normal noise vector z into the generator G and forward-propagating it to the third transposed convolutional block for extraction. Similarly, the intermediate features of unreasonable samples are obtained by inputting another independent noise vector z' into the generator G and forward-propagating it to the third transposed convolutional block for extraction. The performance responses of reasonable and unreasonable samples are taken from the original true performance response y and the perturbed response after applying random scaling and sign inversion, respectively. Their violation score labels are calculated based on the physical residuals as described above. All training samples are uniformly stored as (y... sample , f G_sample , s label ) triplet. Where y sample Is it a reasonable sample or an unreasonable sample, f G_sample It is an intermediate feature, s label These are labels. The original design variable x and the noise vector z are not used as inputs to R; x is only used to compute the physical residual r(y,x) to generate the supervision labels s. labelWhen used, z is only used for generator sampling. This design ensures that the evaluation of R is purely based on the curve shape and its generated representation, avoiding the learning of spurious correlations with the design variables and ensuring generalization. The pre-training dataset consists of an equal number of reasonable samples (label 0) and unreasonable samples (labels 0.5–1.0). The loss function of R is expressed as the mean squared error loss L. R : ; The loss function is trained using regression, with Adam selected as the optimizer and a learning rate of 0.001, until the loss on the validation set converges. The pre-trained physics regularizer R already possesses a preliminary ability to judge physical plausibility, and its judgment is based on the statistics of the residual distribution of the training data (the residual mean μ). r Therefore, it is adaptive to engineering problems of different magnitudes.

[0033] A pre-trained forward mapping network F is used; real design variables are used as input samples, and real performance responses are used as labels to train the forward mapping network. The loss function is the mean squared error loss between the output and labels of the forward mapping network F.

[0034] 2) In the joint training phase, the generator G, inverse generator IG, discriminator D, and forward mapping network F are trained jointly. In each iteration, the random noise vector z∈ 100 Virtual responses are generated through forward propagation of generator G. Real performance response y and virtual response The values ​​are fed into the inverse generator IG, which outputs the corresponding design variable mean and logarithmic variance (the actual variance is obtained by exponential calculation); simultaneously, the virtual performance response is... The intermediate features, concatenated with the output of the third transposed convolutional block in generator G, are fed into the physical regularizer R, which outputs the violation score s. Discriminator D receives y or Output a discriminant score to provide adversarial supervision. The forward mapping network F receives the true design variable x or a back-sampled variable reparameterized from the distribution output by the inverse generator IG. , ; Forward mapping network F outputs predicted response It should be noted that, to ensure the joint loss function accurately reflects the inverse error between generation and backpropagation, F should participate in the backpropagation of the total loss and be slowly updated with a learning rate of 1 / 10 of the main network. This is to avoid mismatch between the forward mapping and the current IG output distribution caused by freezing F. The main network is then jointly optimized. The pre-trained parameters of R are loaded as initial values. During joint training, the learning rate of the physical regularizer R is lower than that of the main network (i.e., the main network G, IG, D, F composed of all the sub-networks trained jointly). For example, the learning rate of R can be set to 0.1 times that of the main network, or the parameters of R can be kept fixed, allowing R to be slowly fine-tuned to adapt to the virtual data distribution that the generator G is learning, while maintaining the acquired physical discriminative ability. For example, the optimizer uses Adam with an initial learning rate of 0.0001, multiplied by 0.9 every 100 iterations.

[0035] The following joint loss function is used for training: ; ; ; ; ; ~N(0,I); in, For the joint loss function, These are the weighting coefficients for each loss term; For the inverse generator's response to virtual performance The mean of the output variance vector. E is an intermediate feature output from the third transposed convolutional block in the generator. z This represents the mathematical expectation of the distribution of a random noise vector z. It is the virtual performance response output by the generator. For real performance response and virtual performance response Random interpolation points between them To improve virtual performance response and intermediate features The scalar score input to the output of the physics regularizer L GAN To counter WGAN-GP losses, L inv To perceive the reverse loss of uncertainty, L cyc G(z) represents the cycle consistency loss; G(z) is the virtual performance response of inputting random noise z to the generator output. The score output by the discriminator. This represents the average score given by the discriminator to the samples generated by the generator. The smaller the value, the stronger the generator's ability to fool the discriminator. D(y) is the output of the discriminator when the true performance response y is input to it. This represents the average score given by the discriminator to the true performance response y. To counteract the internal weights of loss, To make random interpolation points The gradient from the input to the output of the discriminator. This indicates that for random interpolation points The expected value of the distribution is calculated; B is the batch sample size, and d is the dimension of the design variable. Let j be the actual design variable in the j-th dimension corresponding to the i-th actual performance response. It takes the i-th real performance response as input to the inverse generator and outputs the j-th component of the mean vector, which corresponds to the estimated value of the j-th dimension design variable. It is the variance of the output after inputting the i-th real performance response into the inverse generator; Sampling is performed from the distribution output by the inverse generator using reparameterization techniques; These are respectively the virtual performance response The mean and variance are obtained by inputting into the inverse generator; The parameters are N(0,I); F( ) to sample The reconstruction performance response from input to output of the forward mapping network; This is a constraint metric used to measure the difference between the virtual performance response and the reconstructed performance response. It is used to verify the logical consistency within the model, specifically the difference between the "generated" and "reconstructed" graphs. A smaller difference indicates a more consistent "generation → reverse engineering → reconstruction" closed loop, ensuring that the virtual response does not contradict the design variables, thereby improving model reliability. The operation is element-wise multiplication, meaning that the values ​​at corresponding positions of two vectors or matrices with the same dimension are multiplied separately. During joint training, through the explicit appearance of the joint loss function Factors, for different samples and The contributions are dynamically weighted. When the uncertainty of the model's back-calculation results for the current samples is high ( When the uncertainty confidence level is high, the strength of the cyclic consistency and physical constraints is automatically reduced to prevent the model from forcibly learning unreliable mappings in uncertain regions; conversely, when the model confidence level is high, these constraints are strengthened. This adaptive weighting mechanism based on uncertainty confidence level is the core of this application that distinguishes it from existing loose combinatorial techniques.

[0036] Optionally, during the backpropagation process of joint training, the output of the physical regularizer R is used to adjust the gradient update step size of the inverse generator IG in regions of high uncertainty. Specifically, during the backpropagation of joint training, a weight factor derived from the R output score s is introduced when calculating the gradient of the inverse generator IG. Specifically, for each training sample, the original gradient of IG is multiplied by exp(-α·s), where α is a positive hyperparameter (typically 2.0). When R determines that the current sample has a severe physical violation (large s), this weight factor decreases, thereby reducing the gradient update step size of IG on that sample; conversely, if the sample is physically reasonable (s close to 0), the normal update step size is maintained. This mechanism allows the model to cautiously update the inverse generator in regions of high uncertainty and physical inconsistency, avoiding the learning of unreliable mappings.

[0037] 3) End-to-end fine-tuning stage: Unfreeze the physical regularizer R, and perform end-to-end fine-tuning of the generator G, inverse generator IG, physical regularizer R, discriminator D, and forward mapping network F using a learning rate less than a set value (e.g., 0.00001). The inputs and outputs of each sub-network are as follows: Generator G receives noise z and generates a virtual performance response. The inverse generator IG receives either the real performance response y or the virtual performance response. Output respectively or R receives the concatenated vector. Output the violation score s; D receives y or Output the discrimination score; F receives the actual design variable x or the reparameterized sampled value. Output predictive performance response F( This stage uses the same total loss function as the joint training. L total Optimization is performed, with all sub-network parameters participating in backpropagation updates. Unfreezing R further adapts it to the generated data distribution, while a small learning rate maintains its pre-trained physical discriminative ability. Optionally, feedback adjustment of the IG gradient by R continues (the original gradient of the inverse generator multiplied by...). , =2.0), automatically reducing the update step size of IG in regions with severe physical violations. Physical constraint loss on the validation set. If the score does not drop after 20 consecutive rounds, training should be stopped.

[0038] S140. Sample multiple noise vectors from a standard normal distribution, propagate them forward to the generator to obtain multiple virtual performance responses, and input each virtual performance response into the inverse generator to obtain the mean and variance of each design variable.

[0039] S150. Based on the mean and logarithmic variance of each design variable, construct confidence intervals for the design variables to obtain dummy design variables. Optionally, the confidence intervals are 95% confidence intervals.

[0040] Sample multiple noise vectors {z} from a standard normal distribution k}, where k is the index of the noise vector, is forward propagated to the generator G to obtain multiple virtual performance responses. For each The mean is obtained by feeding it into the inverse generator IG. and variance Then each design variable The 95% confidence interval is , , The design variables for the j-th dimension are respectively the k-th input noise vector. The mean and standard deviation. The final generated dataset includes: virtual performance response. The estimated design variables μ, the variance σ² of each dimension, and the corresponding noise vector.

[0041] Optionally, a surrogate model can be trained using the generated virtual dataset (including the mean and variance of design variables), and multi-objective robust optimization can be performed based on the surrogate model (e.g., using NSGA-II to solve optimization problems with uncertain constraints). After the optimized solution is verified by simulation, the verification data can be added back to the training set for iterative updates.

[0042] This application's embodiments output estimated values ​​and fluctuation ranges of design variables, enabling technicians to proactively avoid high-risk areas; it replaces fixed thresholds with learnable regularizers, automatically adapting to data distribution and significantly reducing physical violations; and it enhances the internal logical consistency of the model by forming an approximately invertible mapping through cycle consistency loss. Uncertainty quantification, cycle consistency constraints, and learnable physical regularization work synergistically, each indispensable, with effects far exceeding any pairwise combination, demonstrating non-obviousness. Validation through automotive crash case studies shows that the virtual data generated in this application, used for design optimization, increases total energy absorption and reduces performance fluctuations in actual simulations.

[0043] The following is a specific implementation method: This implementation method addresses the development needs of a new vehicle model: optimizing design variables for key energy-absorbing structures such as the front longitudinal beam and B-pillar to increase total energy absorption during a frontal collision while controlling the peak collision force to remain below a safety threshold. Traditional methods require hundreds of high-fidelity finite element simulations, resulting in high costs and long development cycles. This implementation method, however, utilizes only a small amount of real simulation data (no more than 50 sets) to construct a designable generative model and complete robust design. To this end, source and target domain data are first organized: the source domain data comes from 185 sets of collision simulation results from the previous generation vehicle model, each set containing real design variables x (dimension 4, specifically the thickness of the front longitudinal beam outer plate X1, the thickness of the B-pillar inner plate X2, the thickness of the sill beam reinforcement plate X3, and the yield strength of the A-pillar material X4) and real performance response y (i.e., a force-displacement curve with a length of 200). The target domain data consists of only 40 sets of high-fidelity simulations for the new vehicle model, with the same data definitions. Simultaneously, a fundamental mechanical law is introduced: energy conservation, meaning the work done by external forces should equal the increase in the internal energy of the structure, thus defining the physical residual. The internal energy is obtained by numerical integration of the force-displacement curve. This residual will serve as the input for subsequent adaptive physical constraints.

[0044] Next, a designable generative model is constructed. The generator G takes a 100-dimensional random noise vector z sampled from a standard normal distribution as input, maps it to 4096 dimensions through a fully connected layer, and reshapes it into a 64×64 feature map. After four transposed convolutional blocks, it finally outputs a virtual force-displacement curve of length 200. The inverse generator IG takes as input real or virtual force versus displacement curves. Its backbone consists of five one-dimensional convolutional layers followed by a global average pooling layer, then splits into two parallel fully connected headers: a mean header outputting the mean estimate μ of the design variables, and a variance header outputting the log-variance log(σ²), where the actual variance σ² = exp(log(σ²)). For virtual performance response... IG output For the actual performance response y, the output is... .in The uncertainty of inferring design variables from the collision curve is quantified. A large value indicates that the inference of the front longitudinal beam thickness is unreliable, warranting caution. The learnable physical regularizer R responds to the virtual performance output of the generator. and the intermediate features of its penultimate layer As input, a small convolutional network (3 convolutional layers + global pooling + 2 fully connected layers) outputs a scalar s, representing... The degree of violation of energy conservation is categorized as 0 (completely reasonable) and 1 (severely unreasonable). R acquires adaptive capabilities through pre-training: it automatically constructs reasonable samples (label 0) and unreasonable samples (labels 0.5–1.0) using physical residuals for regression training, enabling it to learn reasonable boundaries based on data distribution statistics, rather than manually fixed thresholds. Furthermore, the discriminator D employs a WGAN-GP architecture, using 5 layers of one-dimensional convolutions to distinguish between real and generated responses, providing adversarial supervision for the generator.

[0045] After model training is complete, virtual data with uncertainty can be generated. This involves using a pre-trained, parameter-frozen generator G and an inverse generator IG to produce new samples through a forward propagation process (rather than the training process). 5000 noise vectors z are sampled from a standard normal distribution. k The generator G generates 5000 virtual force versus displacement curves. Then each Input into IG to obtain the mean of the design variables. and standard deviation For example, the output corresponding to a certain virtual curve is =[1.85mm, 1.52mm, 1.68mm, 365MPa], =[0.08mm, 0.12mm, 0.10mm, 18MPa], meaning the front longitudinal beam thickness is most likely 1.85mm, with a 95% probability of falling within the range [1.69, 2.01]mm. Using these 5000 sets of virtual data, a final surrogate model (such as a Gaussian process) is trained, and then a robust optimization problem is constructed: the biobjectives are maximizing total energy absorption and minimizing uncertainty metric; constraints include peak impact force ≤ 150kN, front longitudinal beam thickness x1 ≤ 2.2mm, and the robust constraint "the sensitivity of peak impact force + 1.96 × peak force to uncertainty ≤ 150kN" (sensitivity is calculated using a first-order Taylor expansion). The Pareto front is solved using the multi-objective evolutionary algorithm NSGA-II, from which a compromise solution is selected, for example, x = [1.92mm, 1.60mm, 1.75mm, 390MPa]. Finally, the solution was substituted into a high-fidelity finite element model for verification. The results showed that the actual total energy absorption was improved by 7.2% compared with the traditional method, the standard deviation of the peak collision force was reduced by about 15%, and all constraints were satisfied.

[0046] Through the above implementation process, this application forms a complete technical solution: it quantifies the uncertainty of reverse inference, enabling engineers to proactively avoid high-risk areas; it replaces fixed physical thresholds with learnable regularizers to automatically adapt to different data distributions; it solves the defect of inconsistency between generation and reverse inference through cyclic consistency loss; it generates 5000 sets of virtual data that conform to physical laws under the condition of scarce real data (only 40 sets), and successfully derives a design scheme with better performance and more robustness.

[0047] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this application can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution disclosed in this application can be achieved, and this is not limited herein.

[0048] The specific embodiments described above do not constitute a limitation on the scope of protection of this application. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this application should be included within the scope of protection of this application.

Claims

1. A method for designing data augmentation meta-modeling, characterized in that, include: Obtain the real design variables and real performance response of mature products, and input the candidate design variables proposed for the product to be designed into the simulation model for calculation to obtain the target design variables and target performance response; Build a designable generative model, including: generator, inverse generator, physical regularizer, discriminator and forward mapping network; The designable generative model is trained; Multiple noise vectors are sampled from a standard normal distribution and forward-propagated to a generator to obtain multiple virtual performance responses. Each virtual performance response is then input into the inverse generator to obtain the mean and variance of each design variable. Confidence intervals for each design variable are constructed based on its mean and logarithmic variance, thus obtaining the virtual design variables.

2. The method according to claim 1, characterized in that, The generator takes a random noise vector as input and outputs a virtual performance response. The input to the inverse generator is the virtual performance response or the real performance response, and the output is the probability distribution parameters of the design variables, including: mean and logarithmic variance; The physical regularizer takes as input the virtual performance response and intermediate features from the output of the third transposed convolutional block in the generator, and outputs a scalar score. The discriminator takes the virtual performance response or the real performance response as input and outputs a discrimination score. The input to the forward mapping network is the mean of the actual design variables or the design variables output by the inverse generator, and the output is the predicted performance response.

3. The method according to claim 2, characterized in that, The generator has the following structure: Fully connected layers, multiple transposed convolutional blocks, adaptive average pooling layers, and flattening layers; Each transposed convolutional block includes a transposed convolutional layer, a batch normalization layer, and a ReLU activation function.

4. The method according to claim 3, characterized in that, The structure of the inverse generator includes a convolutional feature extractor connected in parallel with a mean head and a variance head; The mean header uses linear activation, and the variance header uses linear and exponential operations to obtain the logarithmic variance.

5. The method according to claim 4, characterized in that, The physical regularizer uses a neural network structure; The discriminator structure includes: an input layer, a first convolutional layer, a LeakyReLU activation function, a second convolutional layer, a normalization and LeakyReLU activation function, a third convolutional layer, a normalization and LeakyReLU activation function, a fourth convolutional layer, a normalization and LeakyReLU activation function, and a fifth convolutional layer connected in sequence. The structure of the forward mapping network includes: a fully connected layer, a feature transformation layer, and multiple transposed convolutional blocks connected in sequence; each transposed convolutional block includes a transposed convolutional layer, a batch normalization layer, and a ReLU activation function.

6. The method according to claim 5, characterized in that, Training the designable generative model includes: The target performance response is used as the input sample, and the mean of the target design variable is used as the label to train the convolutional feature extractor and mean head of the inverse generator. The real performance response is used as a reasonable sample, and the physical residual is calculated based on energy conservation and mapped to a violation score label; the real performance response is perturbed and used as an unreasonable sample, and the physical residual is calculated based on energy conservation and mapped to a violation score label; the physical regularizer is trained using the reasonable sample, the unreasonable sample, the intermediate features output by the third transposed convolutional block in the generator, and the corresponding violation score labels. The real design variables are used as input samples, and the real performance responses are used as labels to train a forward mapping network. The system jointly trains a generator, an inverse generator, a discriminator, and a forward mapping network; during joint training, the learning rate of the physical regularizer is lower than that of the main network, or its parameters remain fixed. Unfreeze the physical regularizer and fine-tune the generator, inverse generator, physical regularizer, discriminator, and forward mapping network using a learning rate less than a set value.

7. The method according to claim 6, characterized in that, Design variables include: vehicle parameters that affect vehicle collision performance in car collision simulation scenarios; performance response includes the sequence of collision force changes with displacement; The method calculates physical residuals based on energy conservation and maps them to violation score labels, including: integrating the impact load with respect to the vehicle displacement to obtain the work done by the external force; integrating the collision force with respect to the displacement to obtain the increase in internal energy of the structure; using the absolute difference between the work done by the external force and the increase in internal energy of the structure as the physical residual; and mapping the physical residuals to violation score labels using a preset mapping formula. Applying a perturbation to the true performance response includes: randomly scaling and reversing the sign of the true performance response, such that the perturbed residual is greater than or equal to twice the average residual of a reasonable sample.

8. The method according to claim 7, characterized in that, The joint training of the generator, inverse generator, discriminator, and forward mapping network includes: The following joint loss function is used for training: ; ; ; ； ； ~N(0,I); in, For the joint loss function, These are the weighting coefficients for each loss term; For the inverse generator's response to virtual performance The mean of the output variance vector. E is an intermediate feature output from the third transposed convolutional block in the generator. z This represents the mathematical expectation of the distribution of a random noise vector z. It is the virtual performance response output by the generator. For the real performance response y and the virtual performance response Random interpolation points between them To improve virtual performance response and intermediate features The scalar score input to the output of the physics regularizer L GAN To counter WGAN-GP losses, L inv To perceive the reverse loss of uncertainty, L cyc G(z) represents the cycle consistency loss; G(z) is the virtual performance response of inputting random noise z to the generator output. The score output by the discriminator. This represents the average score given by the discriminator to the samples generated by the generator. The smaller the value, the stronger the generator's ability to fool the discriminator. D(y) is the output of the discriminator when the true performance response y is input to it. This represents the average score given by the discriminator to the true performance response y. To counteract the internal weights of loss, To make random interpolation points The gradient from the input to the output of the discriminator. Indicates the random interpolation point The expected value of the distribution is calculated; B is the batch sample size, and d is the dimension of the design variable. Let j be the actual design variable in the j-th dimension corresponding to the i-th actual performance response. It takes the i-th real performance response as input to the inverse generator and outputs the j-th component of the mean vector, which corresponds to the estimated value of the j-th dimension design variable. It is the variance of the output after inputting the i-th real performance response into the inverse generator; Sampling is performed from the distribution output by the inverse generator using reparameterization techniques; These are respectively the virtual performance response The mean and variance are obtained by inputting into the inverse generator; The parameters are N(0,I); F( ) to sample The reconstruction performance response from input to output of the forward mapping network; This is a constraint metric used to measure the difference between virtual performance response and reconfigured performance response; the ⊙ operation is element-wise multiplication.

9. The method according to claim 8, characterized in that, During the backpropagation process of the joint training, the original gradient of the inverse generator is multiplied by exp(-α·s); Where α is a positive hyperparameter and s is the scalar fraction output by the physical regularizer.

10. The method according to claim 9, characterized in that, The confidence interval is a 95% confidence interval.

Images