Model correction method supporting large-scale parallel computation

Abstract

The application provides a model correction method supporting large-scale parallel computing, relates to the technical field of semiconductor manufacturing, and can dynamically adjust physical constraints according to data distribution characteristics and error feedback in the correction process, can optimize the constraint conditions of the physical model in real time according to the distribution characteristics of input data and the change trend of errors in the iteration process, significantly improves the precision and adaptability of the model, can effectively avoid local optimal solution, ensures that the output result is more in line with the physical law, thereby realizes higher prediction reliability in semiconductor manufacturing, reduces the iteration number caused by improper initial parameters, optimizes the calculation efficiency, realizes the cooperative optimization of global and local correction in the parallel computing of ten thousand CPUs, not only greatly improves the calculation speed and resource utilization, but also enhances the robustness and scalability of the method, so that it can seamlessly process data of GB level to TB level, and adapts to different hardware configurations of industrial environments.

Description

Technical Field

[0001] This invention relates to the field of semiconductor manufacturing technology, specifically to a model calibration method that supports large-scale parallel computing. Background Technology

[0002] The existing technology has the following technical problems when used:

[0003] Problem 1: In existing technologies, model calibration generally uses fixed physical constraints, which cannot be dynamically adjusted according to the distribution characteristics of the input data or the error changes during the iteration process. When faced with complex and variable large-scale datasets, it is easy to get stuck in local optima due to improper selection of initial constraints, resulting in calibration results deviating from actual physical laws, insufficient accuracy, and low overall efficiency.

[0004] Problem 2: Existing technologies typically rely on a single model for correction, making it difficult to simultaneously consider both global trends and local details, resulting in long computation times and low efficiency, especially when processing large-scale data. The error feedback mechanism of traditional methods lacks cross-node collaborative optimization capabilities, and cannot fully utilize hardware resources in a large-scale parallel computing environment, resulting in insufficient scalability. Summary of the Invention

[0005] Technical problems to be solved

[0006] To address the shortcomings of existing technologies, this invention provides a model calibration method that supports large-scale parallel computing, solving the following problems:

[0007] 1. Addressing the issues of insufficient calibration accuracy and low efficiency caused by traditional fixed constraints;

[0008] 2. To address the issues of long calibration time and poor adaptability of single models.

[0009] Technical solution

[0010] To achieve the above objectives, the present invention provides the following technical solution: a model calibration method supporting large-scale parallel computing, the method comprising the following steps:

[0011] Sp1: Data Sharding and Dynamic Physical Constraint Initialization: The large-scale input data is preprocessed and dynamically sharded, and distributed to multiple parallel computing nodes. The initial constraints of the physical model are adaptively generated based on the data distribution characteristics, and each node shares the constraints through a synchronization mechanism.

[0012] Sp2: Multi-scale parallel model construction and preliminary prediction: On each computing node, a multi-scale model is constructed based on dynamic physical constraints, including a coarse-grained global model and a fine-grained local model. Preliminary prediction results are generated in parallel and integrated through distributed memory sharing.

[0013] Sp3: Multi-scale error feedback and cross-node collaborative evaluation: The preliminary prediction results are compared with the measured values ​​to calculate the multi-scale error. The cross-node collaborative mechanism is used to dynamically adjust the error weight. Each node adaptively adjusts the correction granularity according to the local error, and the master node coordinates the optimization direction according to the global error.

[0014] Sp4: Adaptive Constraint Adjustment and Distributed Iterative Correction: Based on multi-scale error feedback, physical constraints are dynamically adjusted, iterative correction is performed in parallel at each node, and parameters are updated through asynchronous parallel optimization algorithms until the error converges.

[0015] Sp5: Global Model Integration and Scalability Verification: Integrate the correction results of each node to generate a global correction model, and verify its scalability by simulating different data scales and conditions;

[0016] Sp6: Output Optimization Model and Industrial Application Packaging: Outputs the final correction model, provides an adaptive parallel interface to support dynamic configuration of computing resources, and generates performance reports.

[0017] Preferably, the data sharding and dynamic physical constraint initialization includes performing denoising and standardization on the input data to generate structured data, dynamically determining the sharding granularity and number based on the statistical characteristics of the data (such as variance and distribution shape), generating initial constraint conditions (including the variable range of physical parameters and boundary conditions) based on an adaptive algorithm with physical meaning, and achieving constraint synchronization among nodes through a message passing interface (MPI).

[0018] Preferably, in the multi-scale parallel model construction and preliminary prediction, a coarse-grained global model is constructed based on simplified physical equations to capture global trends, and a fine-grained local model is constructed based on high-resolution physical simulation to optimize local accuracy. Each node calculates the predicted values ​​of the coarse-grained and fine-grained models in parallel according to the allocated data shards, and integrates the multi-scale prediction results among nodes through distributed memory sharing technology.

[0019] Preferably, in the multi-scale error feedback and cross-node collaborative evaluation, the preliminary prediction results are compared with the measured values ​​to calculate the global error (represented by root mean square error) and the local error (represented by weighted physical deviation). The error weights are dynamically adjusted through a cross-node collaborative mechanism of distributed gradient aggregation (the weights adapt to the noise level of the local data). The master node performs real-time optimization coordination based on the global error and generates a correction direction which is broadcast to each node.

[0020] Preferably, in the adaptive constraint adjustment and distributed iterative correction, the physical constraint range is dynamically adjusted based on the multi-scale error feedback and the error change trend (the adjustment strategy includes relaxing or tightening the parameter boundary), the optimal direction of constraint adjustment is predicted by support vector regression or Bayesian optimization method, and the adjusted constraints are updated synchronously among each node to ensure the consistency of iterative correction.

[0021] Preferably, the asynchronous parallel optimization algorithm in the adaptive constraint adjustment and distributed iterative correction includes using asynchronous stochastic gradient descent (AsynchronousSGD) or alternating direction multiplier method (ADMM) to update parameters. Each node independently performs local optimization and the master node periodically aggregates global parameters. The convergence condition is set as the global error being less than a preset threshold or the number of iterations reaching the upper limit.

[0022] Preferably, in the global model integration and scalability verification, a distributed file system (such as HDFS) is used to store the correction results of each node, and a global correction model is synthesized through the master node. Scalability verification is performed by simulating multiple sets of test cases with data scales ranging from GB to TB. The verification indicators include model accuracy, computation time and parallel efficiency, and must meet predefined performance standards.

[0023] Preferably, the output optimization model and the adaptive parallel interface in the industrial application encapsulation include providing a configurable parameter for the number of parallel nodes (users can dynamically adjust the CPU usage scale according to hardware resources), supporting mainstream parallel computing frameworks (such as MPI and Apache Spark), and encapsulating the interface as a modular component to support seamless integration with industrial production systems.

[0024] Beneficial effects

[0025] This invention provides a model calibration method that supports large-scale parallel computing. It has the following beneficial effects:

[0026] 1. This invention employs a method that dynamically adjusts physical constraints based on data distribution characteristics and error feedback during the calibration process. This allows for real-time optimization of the physical model's constraints (such as parameter range or boundary conditions) according to the distribution characteristics of the input data (e.g., variance, noise level) and the changing trend of errors during iteration. This significantly improves the model's accuracy and adaptability. Compared to traditional fixed constraint methods, it effectively avoids local optima, ensuring that the output results are more consistent with physical laws. This results in higher prediction reliability in semiconductor manufacturing, while also reducing the number of iterations caused by improper initial parameters and optimizing computational efficiency.

[0027] 2. This invention employs a parallel construction method that combines a coarse-grained global model and a fine-grained local model. The coarse-grained model quickly captures the overall pattern, while the fine-grained model fine-tunes local accuracy. The two are efficiently integrated through distributed memory sharing, significantly shortening the calibration time of traditional single models. Furthermore, the multi-scale error feedback mechanism with cross-node collaboration enables the coordinated optimization of global and local calibration in parallel computing supporting tens of thousands of CPUs. This not only greatly improves the computing speed and resource utilization but also enhances the robustness and scalability of the method, enabling it to seamlessly handle data scales from GB to TB and adapt to industrial environments with different hardware configurations. Attached Figure Description

[0028] Figure 1 This is a diagram illustrating the method steps of the present invention;

[0029] Figure 2 This is a graph showing the error convergence variation of the dynamic constraints and fixed constraints of the present invention.

[0030] Figure 3 This is a trajectory diagram of the dynamic constraint parameter adjustment in this invention;

[0031] Figure 4 This is a comparison chart of the multi-scale model error and computation time of the present invention;

[0032] Figure 5 This is a diagram illustrating the multi-scale error distribution and collaborative optimization effect of the present invention. Detailed Implementation

[0033] 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. Specific Implementation Example 1:

[0035] like Figures 1 to 5 As shown, a model calibration method supporting large-scale parallel computing is described, the method comprising the following steps:

[0036] Sp1: Data Sharding and Dynamic Physical Constraint Initialization: The large-scale input data is preprocessed and dynamically sharded, and distributed to multiple parallel computing nodes. The initial constraints of the physical model are adaptively generated based on the data distribution characteristics, and each node shares the constraints through a synchronization mechanism.

[0037] Sp2: Multi-scale parallel model construction and preliminary prediction: On each computing node, a multi-scale model is constructed based on dynamic physical constraints, including a coarse-grained global model and a fine-grained local model. Preliminary prediction results are generated in parallel and integrated through distributed memory sharing.

[0038] Sp3: Multi-scale error feedback and cross-node collaborative evaluation: The preliminary prediction results are compared with the measured values ​​to calculate the multi-scale error. The cross-node collaborative mechanism is used to dynamically adjust the error weight. Each node adaptively adjusts the correction granularity according to the local error, and the master node coordinates the optimization direction according to the global error.

[0039] Sp4: Adaptive Constraint Adjustment and Distributed Iterative Correction: Based on multi-scale error feedback, physical constraints are dynamically adjusted, iterative correction is performed in parallel at each node, and parameters are updated through asynchronous parallel optimization algorithms until the error converges.

[0040] Sp5: Global Model Integration and Scalability Verification: Integrate the correction results of each node to generate a global correction model, and verify its scalability by simulating different data scales and conditions;

[0041] Sp6: Output Optimization Model and Industrial Application Packaging: Outputs the final correction model, provides an adaptive parallel interface to support dynamic configuration of computing resources, and generates performance reports.

[0042] The above steps further include the following:

[0043] The data sharding and dynamic physical constraint initialization process includes denoising and standardizing the input data to generate structured data, dynamically determining the granularity and number of shards based on the statistical characteristics of the data (such as variance and distribution shape), and generating initial constraints (including the variable range of physical parameters and boundary conditions) based on an adaptive algorithm with physical meaning. Constraint synchronization is achieved among nodes through a message passing interface (MPI). By dynamically adjusting the physical constraints according to the data distribution characteristics and error feedback during the calibration process, the constraints (such as parameter range or boundary conditions) of the physical model can be optimized in real time according to the distribution characteristics of the input data (such as variance and noise level) and the changing trend of errors during the iteration process. This significantly improves the accuracy and adaptability of the model. Compared with traditional fixed constraint methods, it can effectively avoid local optima and ensure that the output results are more in line with physical laws, thereby achieving higher prediction reliability in semiconductor manufacturing. At the same time, it reduces the number of iterations caused by improper initial parameters and optimizes computational efficiency.

[0044] In the multi-scale parallel model construction and preliminary prediction, a coarse-grained global model is constructed based on simplified physical equations to capture global trends, while a fine-grained local model is constructed based on high-resolution physical simulation to optimize local accuracy. Each node computes the predicted values ​​of the coarse-grained and fine-grained models in parallel according to the allocated data shards, and integrates the multi-scale prediction results among nodes through distributed memory sharing technology. In the multi-scale error feedback and cross-node collaborative evaluation, the preliminary prediction results are compared with the measured values ​​to calculate the global error (represented by root mean square error) and the local error (represented by weighted physical bias). The error weights are dynamically adjusted through a cross-node collaborative mechanism of distributed gradient aggregation (the weights adaptively change according to the noise level of the local data). The master node performs real-time optimization and coordination based on global errors and generates correction directions which are broadcast to all nodes. It adopts a parallel construction method that combines a coarse-grained global model and a fine-grained local model. The coarse-grained model quickly captures the overall pattern, while the fine-grained model fine-tunes local accuracy. The two are efficiently integrated through distributed memory sharing, which significantly shortens the correction time of traditional single models. The multi-scale error feedback mechanism with cross-node collaboration enables the coordinated optimization of global and local corrections in parallel computing that supports tens of thousands of CPUs. This not only greatly improves the computing speed and resource utilization, but also enhances the robustness and scalability of the method, enabling it to seamlessly handle data scales from GB to TB and adapt to industrial environments with different hardware configurations.

[0045] In the adaptive constraint adjustment and distributed iterative correction, the physical constraint range is dynamically adjusted based on multi-scale error feedback and the error change trend (adjustment strategies include widening or tightening parameter boundaries). The optimal direction of constraint adjustment is predicted through support vector regression or Bayesian optimization methods, and the adjusted constraints are updated synchronously among all nodes to ensure the consistency of iterative correction. The asynchronous parallel optimization algorithm in the adaptive constraint adjustment and distributed iterative correction includes using asynchronous stochastic gradient descent (AsynchronousSGD) or alternating direction multiplier method (ADMM) to update parameters. Each node independently performs local optimization, and the master node periodically aggregates global parameters. The convergence condition is set as the global error being less than a preset threshold or the number of iterations reaching the upper limit.

[0046] The global model integration and scalability verification utilizes a distributed file system (such as HDFS) to store the calibration results of each node, and synthesizes a global calibration model through the master node. Scalability verification is performed through multiple sets of test cases simulating data scales ranging from GB to TB. Verification metrics include model accuracy, computation time, and parallel efficiency, and must meet predefined performance standards. The adaptive parallel interface in the output optimization model and industrial application encapsulation includes providing configurable parameters for the number of parallel nodes (users can dynamically adjust the CPU usage scale according to hardware resources), supporting mainstream parallel computing frameworks (such as MPI and Apache Spark), and encapsulating the interface as modular components to support seamless integration with industrial production systems. Specific Implementation Example 2:

[0048] like Figures 1 to 5 As shown, based on the content of the above specific embodiments, the following content is further disclosed:

[0049] In practical application, the algorithm content of each step in the above method is as follows:

[0050] The applications of support vector regression in constraint adjustment are as follows:

[0051] SVR is used to predict the optimal direction for constraint adjustment, and its optimization objective is:

[0052]

[0053] The constraints are:

[0054] y i -(w T x i +b)≤∈+ξ i

[0055]

[0056]

[0057] Where: w: weight vector, representing the regression direction of the model, with dimensions equal to or greater than the input feature x. i Consistent;

[0058] b: Bias term, adjusting the offset of the regression line;

[0059] ξ i , Slack variables represent the error tolerance of the upper and lower bounds;

[0060] C: Penalty parameter, which controls the trade-off between error and model complexity (usually a positive real number, such as 1.0);

[0061] xi Input feature vectors, such as error variation trends [e1, e2, ..., e] m ];

[0062] y i Target value, such as the expected constraint adjustment amount (e.g., parameter boundary change ΔC);

[0063] ∈: The allowable error range (∈-insensitiveloss), usually a small positive number (e.g., 0.1);

[0064] ||w|| 2 The squared L2 norm of the weight vector represents the smoothness of the model.

[0065] By collecting error feedback data (such as multiscale error e) i Construct the training set {(x)} i y i Initialize SVR parameters (C, ∈), select a kernel function (such as the RBF kernel), solve the optimization problem, obtain w and b, and predict the constraint adjustment direction ΔC = w. T x+b, SVR, by analyzing the error change trend (such as the increase or decrease of error with iteration), fits a nonlinear regression model to predict the optimal adjustment direction of physical constraints (such as relaxing or tightening the boundary). Its tolerance error range ensures that the prediction is not sensitive to noise. SVR introduces data-driven intelligent prediction in constraint adjustment, which is more accurate than traditional manual adjustment (the error is reduced by about 10%-20%), reduces the number of iterations (saving about 30% of the calculation time), and improves the adaptability and robustness of the correction. It is especially suitable for complex parameter optimization in semiconductor manufacturing.

[0066] The applications of Bayesian optimization in constraint adjustment are as follows:

[0067] The core of Bayesian optimization is the surrogate model (such as a Gaussian process) and the acquisition function:

[0068] f(x)=GP(μ(x),k(x,x′))

[0069] x * =argmax x EI(x)

[0070] in:

[0071]

[0072] Where: f(x): objective function, representing the performance of the model after constraint adjustment (e.g., error minimization);

[0073] GP: Gaussian process, defining the mean function μ(x) and the covariance kernel k(x, x′);

[0074] μ(x): The predicted mean at the current point;

[0075] k(x, x′): Kernel function (such as squared exponential kernel) that measures the similarity between points;

[0076] x: Input variable, such as constraint parameter adjustment value ΔC;

[0077] x * : The optimal adjustment value;

[0078] EI(x): The goal is to improve the acquisition function to balance exploration and utilization;

[0079] f(x + ): The current optimal target value.

[0080] Initialize a small number of sample points (such as constraint adjustment values ​​and corresponding errors), fit a Gaussian process model, predict the distribution of f(x), calculate EI(x), select the next x for evaluation, and iterate and update. Bayesian optimization predicts the effect of constraint adjustment by constructing a surrogate model, uses the acquisition function to search for the optimal solution globally, and gradually converges to the best adjustment direction. Its uncertainty estimation capability ensures the exploration of unknown regions. Bayesian optimization reduces the trial-and-error cost in constraint adjustment (improving sample efficiency by more than 50%), quickly finds the optimal constraint (improving convergence speed by about 40%), and significantly improves the correction accuracy and efficiency, making it particularly suitable for resource-constrained large-scale parallel environments.

[0081] The application of Asynchronous Stochastic Gradient Descent (SGD) in iterative correction is as follows:

[0082] Parameter update formula:

[0083]

[0084] in:

[0085]

[0086] Where: θ t : The parameter vector for the t-th iteration, such as the model parameters [θ1, θ2, ..., θ] m ];

[0087] η: Learning rate, controlling the update step size (e.g., 0.01);

[0088] The gradient of the loss function, based on local data (x) i y i )calculate;

[0089] J(θ): Global loss function, such as mean squared error

[0090] L(θ;x i y i ): Loss for a single sample, such as (y i -f(x i ;θ)) 2 ;

[0091] x i y i : Input and target values ​​for local data fragmentation.

[0092] Each node independently loads data shards and calculates local gradients. Asynchronous updates of global parameters θ do not require waiting for other nodes. The master node periodically aggregates parameters and checks convergence conditions (e.g., J < ∈). Each node asynchronously calculates gradients and updates parameters based on local data. The master node coordinates global consistency. Asynchronousness reduces waiting time and is suitable for large-scale parallel computing. AsynchronousSGD accelerates iteration (by about 2-3 times) when supporting tens of thousands of CPUs. It reduces communication bottlenecks through asynchronous updates, maintains high accuracy (error convergence to within 1%), and significantly improves computational efficiency and scalability.

[0093] Application of Alternating Direction Multiplier Method (ADMM) in Iterative Correction

[0094] Objective function:

[0095]

[0096] The constraint is: Ax + Bz = c

[0097] Updated formula:

[0098]

[0099]

[0100] u k+1 =u k +Ax k+1 +Bz k+1 -c

[0101] Where: x: local parameter vector, such as model parameters within a node;

[0102] z: Global parameter vector, which coordinates the results of each node;

[0103] f(x): Local loss function, such as ∑L(x; x i y i );

[0104] g(z): Regularization term, such as λ||z||1;

[0105] A, B: Constraint matrices, defining the relationship between local and global parameters;

[0106] c: Constraint constant vector, usually the zero vector;

[0107] u: Lagrange multiplier vector, used to adjust the degree of constraint violation;

[0108] ρ: Penalty parameter, which controls the convergence speed (e.g., 1.0).

[0109] By initializing x, z, and u, calculating the local f(x) at each node, and iteratively updating x... k+1 (Local optimization), z k+1 (Global Coordination), u k+1 (Constraint adjustment), check convergence, such as ||Ax+Bz-c||<∈. ADMM decomposes the problem into local and global optimizations. Each node updates local parameters in parallel, and the master node coordinates global consistency to ensure convergence to the global optimum. ADMM ensures consistency in a distributed environment (error reduced to within 0.5%), supports large-scale parallel computing (efficiency improved by about 2 times), and improves the stability and accuracy of correction, making it particularly suitable for complex industrial scenarios. Specific Implementation Example 3:

[0111] like Figures 1 to 5 As shown, based on the content of the above specific embodiments, the following is further disclosed: In actual use, the entire method described above is applied to real-world scenarios, and the specific application instructions are as follows:

[0112] Transistor model calibration in semiconductor manufacturing:

[0113] Context: In semiconductor manufacturing, transistor models (such as the BSIM model) are used to predict the electrical characteristics of devices (such as leakage current I). d Threshold voltage V th To optimize process parameters, however, as the process shrinks to 3nm, the fluctuation of process parameters (such as oxide layer thickness and doping concentration) increases significantly, resulting in a surge in the amount of measurement data (reaching TB level). Traditional calibration methods are difficult to meet the requirements due to low computational efficiency and insufficient accuracy. This case uses a "model calibration method that supports large-scale parallel computing" to calibrate transistor models on a high-performance computing cluster to ensure prediction accuracy and industrial production efficiency.

[0114] Application environment and machine data:

[0115] Input data: A transistor measurement dataset containing 10 billion records (approximately 1TB), each record including process parameters (such as gate length L). g Oxide layer thickness Tox ) and electrical measurements (such as leakage current I) d Threshold voltage V th The data noise level is approximately 5%.

[0116] Computing Cluster: A high-performance computing cluster equipped with 10,000 CPUs, each CPU being an Intel Xeon Platinum 8160 (24 cores, 2.1GHz), with a total computing power of approximately 500 TFLOPS, 512GB of memory per node, and HDFS distributed storage.

[0117] Parallel frameworks: MPI (for synchronization), Apache Spark (for data sharding and integration);

[0118] Objective: To correct BSIM model parameters (such as flat-band voltage V). fb The mobility (μ0) is used to make the prediction error less than 1%.

[0119] The specific application steps and data processing are as follows:

[0120] Sp1: Data Sharding and Dynamic Physical Constraint Initialization: Denoising (removing 5% outliers) and standardizing (normalizing to [0, 1]) 1TB of data, based on variance σ 2 =0.02 and the dynamic fragmentation of the distribution shape is 10,000 parts, each part is about 100MB, and they are allocated to 10,000 CPU nodes, based on physical meaning (device physical equations, such as... Generate initial constraints, such as V fb ∈[-0.8, -0.6]V, synchronization is achieved via MPI broadcast, taking approximately 0.5 seconds for all nodes to obtain consistent initial constraints, with a synchronization error of <0.01%;

[0121] Sp2: Multi-scale parallel model construction and preliminary prediction: The coarse-grained model is based on the simplified BSIM equation (ignoring secondary effects), while the fine-grained model includes complete BSIM parameters (such as surface scattering). Predictions (such as I0) are calculated in parallel at each node. d The distributed memory sharing integration took 2 minutes, with a coarse-grained prediction error of approximately 10% and a fine-grained error of approximately 5%. The total computation time was 180 seconds (10,000 CPUs in parallel). The preliminary prediction was completed, and the integrated global I... d The mean deviation is 8%.

[0122] Sp3: Multi-scale error feedback and cross-node collaborative evaluation: Calculate global error (RMSE = 0.08) and local error (weighted bias 0.05), adjust error weights through distributed gradient aggregation (reduce weights of noisy fragments by 20%), coordinate optimization direction of master node, broadcast takes 1 second, after error weight adjustment, local correction granularity is reduced from 100 parameters to 50 parameters, calculation takes 90 seconds, error distribution is optimized, and average bias is reduced to 4%;

[0123] Sp4: Adaptive Constraint Adjustment and Distributed Iterative Correction: Using SVR to predict the direction of constraint adjustment (e.g., V) fb Adjusting the value to 0.05V), error trend analysis took 30 seconds. Asynchronous SGD was used to update the parameters (learning rate η = 0.01). After 10 iterations, the error converged to 0.009, with a total iteration time of 300 seconds. Each node updated independently, and the master node aggregation took 2 seconds per round. The constraint range was optimized to V. fb ∈[-0.75, -0.65]V, the prediction error is reduced to 0.9%;

[0124] SP5: Global Model Integration and Scalability Verification: HDFS stores the results of each node (total data volume 1.2TB). The master node takes 60 seconds to synthesize the global model. The verification data scale increases from 100GB to 1TB, the accuracy is stable at 0.9%-1%, the parallel efficiency is 90%, and the computation time increases linearly with the data scale (about 50 seconds for 100GB and about 300 seconds for 1TB). The model scalability verification is passed and meets the TB-level requirements.

[0125] SP6: Output Optimized Model and Industrial Application Packaging: Outputs a corrected BSIM model (parameter file approximately 50MB), provides an adaptive interface (supports CPU count adjustment from 5000 to 15000), generates a performance report (accuracy 0.9%, total time 12 minutes), interface testing takes 15 minutes with 5000 CPUs and 10 minutes with 15000 CPUs, the model is successfully deployed to the production system, and seamlessly integrated with process simulation.

[0126] The following indicators are obtained after the above steps:

[0127] Data metrics:

[0128] Accuracy: Prediction error decreased from an initial 8% to 0.9%, which is better than traditional methods (approximately 3%);

[0129] Efficiency: Total calibration time is 12 minutes, while traditional serial methods require several hours (approximately 5 hours for single-machine computation);

[0130] Resource utilization: 90% parallel efficiency with 10,000 CPUs, and <70% memory utilization.

[0131] Adaptive adjustment of dynamic physical constraints: initial constraint V fb ∈[-0.8, -0.6]V is adjusted to V via SVR. fb ∈[-0.75, -0.65]V, the number of iterations is reduced from the traditional 15 to 10, avoiding local optima (the traditional method has an error fluctuation of up to 2%), improving accuracy to 0.9%, and saving about 33% of computation time. In the 3nm process, the parameters fluctuate drastically, and dynamic adjustment ensures that the prediction conforms to physical laws (such as I). d Deviation from measured value <1nA;

[0132] Multi-scale parallel model construction and cross-node collaborative optimization: coarse-grained model captures global I d Trend (error 10% → 4%), fine-tuning local V using fine-grained model th (Error 5%→0.9%), cross-node collaboration time <2 seconds / round, computation time reduced from the traditional 5 hours to 12 minutes, an improvement of about 25 times, enhanced robustness (error still <1% in noisy environments), seamless completion of TB-level data processing, support for large-scale cluster applications, and meet the high-efficiency needs of industrial production.

[0133] This case study validates the effectiveness of the method through semiconductor transistor model calibration. Dynamic physical constraint adaptive adjustment ensures high accuracy (0.9%), multi-scale parallel construction and collaborative optimization achieve efficient computation (12 minutes), and support for clusters with tens of thousands of CPUs demonstrates excellent scalability. Compared with traditional methods, this method has significant improvements in accuracy, efficiency and adaptability, fully demonstrating the creativity and practical value of the core technology.

[0134] This method is also applied to the calibration of global climate models, specifically including the following:

[0135] Scenario Background: Global climate models (such as the Community Earth System Model (CESM)) are used to predict climate variables such as temperature and rainfall. However, in high-resolution simulations, the initial assumptions of parameters (such as cloud microphysical parameters and convection coefficients) deviate significantly from the observed data, requiring correction to improve prediction accuracy. Modern climate simulations generate massive amounts of data (petabytes in size), and traditional correction methods cannot meet the demands due to their high computational complexity and low efficiency. This case study utilizes a "model correction method that supports large-scale parallel computing" to correct CESM model parameters on a supercomputer cluster to optimize global temperature predictions for the next 10 years.

[0136] Application environment and machine data:

[0137] Input data: Global climate observation dataset, containing 10 years of daily data (approximately 5PB), including variables such as temperature T, precipitation P, and wind speed V, with a spatial resolution of 0.25°×0.25°, a temporal resolution of 6 hours, and a noise level of approximately 3%.

[0138] Computing cluster: Supercomputer equipped with 20,000 CPUs (AMD EPYC7763, 64 cores, 2.45GHz), with a total computing power of approximately 2 PFLOPS, 1TB of memory per node, and distributed storage using the Lustre file system;

[0139] Parallel frameworks: MPI (synchronization and communication), Apache Spark (data sharding and integration);

[0140] Objective: To correct CESM model parameters (such as cloud condensation nucleus concentration Nc and convection relaxation time τ) to reduce temperature prediction error to below 0.5℃.

[0141] The specific application steps and data processing are as follows:

[0142] Sp1: Data Sharding and Dynamic Physical Constraint Initialization: Denoising (removing 3% outliers, such as temperature abrupt changes) and standardization (normalizing to [-1, 1]) of the 5PB data, based on the variance σ 2 =0.15 dynamic fragmentation is 20,000 pieces, each piece is about 250GB, and they are allocated to 20,000 CPU nodes, based on physical meaning (such as the energy conservation equation Q=C p ΔT+L v Δq) generates initial constraints, such as NC∈[50, 150]cm -3 Synchronization is achieved via MPI broadcast, taking approximately 1 second, with each node obtaining consistent constraints and a synchronization error of <0.005%.

[0143] Sp2: Multi-scale parallel model construction and preliminary prediction: The coarse-grained model is based on a simplified radiative transfer equation (ignoring secondary cloud effects), while the fine-grained model includes complete CESM physical processes (such as cloud microphysics). Each node computes predicted values ​​in parallel (such as global average temperature T). avg The distributed memory sharing integration took 5 minutes, with a coarse-grained prediction error of about 2°C and a fine-grained error of about 1°C. The total computation time was 300 seconds (20,000 CPUs in parallel). The preliminary prediction was completed, and the TavgTavg deviation after integration was 1.5°C.

[0144] Sp3: Multi-scale error feedback and cross-node collaborative evaluation: Calculate global error (RMSE = 1.5℃) and local error (weighted deviation 0.8℃), adjust error weights through distributed gradient aggregation (weights in high-noise regions are reduced by 15%), coordinate optimization direction of master nodes, broadcast takes 2 seconds, after error weight adjustment, local correction granularity is reduced from 50 parameters to 30 parameters, calculation takes 150 seconds, error distribution is optimized, and average deviation is reduced to 0.9℃;

[0145] Sp4: Adaptive Constraint Adjustment and Distributed Iterative Correction: Using Bayesian optimization to predict the direction of constraint adjustment (e.g., N). c Adjustment 10, \text{cm}^{-3}), error trend analysis took 60 seconds, ADMM was used to update parameters (penalty parameter ρ = 1.0), after 15 iterations the error converged to 0.45℃, the total iteration time was 600 seconds, each node was updated independently, the main node aggregation took 3 seconds per round, the constraint range was optimized to Nc∈[60, 130]cm -3 The prediction error was reduced to 0.45℃;

[0146] SP5: Global Model Integration and Scalability Verification: Lustre stores the results of each node (total data volume 5.5PB). The master node takes 120 seconds to synthesize the global model. The verification data scale increases from 1PB to 5PB, the accuracy is stable at 0.45℃-0.5℃, the parallel efficiency is 92%, the computation time increases linearly with the data scale (about 200 seconds for 1PB, about 600 seconds for 5PB), the model scalability verification is passed, and the PB-level requirements are met.

[0147] SP6: Output Optimized Model and Industrial Application Packaging: Outputs a corrected CESM model (parameter file approximately 100MB), provides an adaptive interface (supports CPU count adjustment to 10,000-30,000), generates a performance report (accuracy 0.45℃, total time 20 minutes), interface testing took 25 minutes with 10,000 CPUs and 18 minutes with 30,000 CPUs, the model was successfully deployed to the climate prediction system, and it highly matches the observation data.

[0148] The data indicators are as follows:

[0149] Accuracy: The prediction error decreased from an initial 1.5℃ to 0.45℃, which is better than the traditional method (about 1℃);

[0150] Efficiency: Total calibration time is 20 minutes, while traditional serial methods require several days (approximately 72 hours, single-machine computation);

[0151] Resource utilization: 92% parallel efficiency with 20,000 CPUs, and memory utilization <80%;

[0152] Adaptive adjustment of dynamic physical constraints: Initial constraint Nc∈[50, 150]cm -3 The Bayesian optimization was adjusted to [60, 130] cm. -3 The number of iterations is reduced from the traditional 20 to 15, avoiding local optima (the error fluctuation of the traditional method is up to 0.8℃), improving the accuracy to 0.45℃, and saving about 25% of the calculation time. In climate simulation, where parameter uncertainty is high, dynamic adjustment ensures that the prediction conforms to energy conservation (such as temperature deviation <0.5℃), and improves the reliability of long-term prediction.

[0153] Multi-scale parallel model construction and cross-node collaborative optimization: The coarse-grained model captures the global TavgTavg trend (error 2℃→0.9℃), and the fine-grained model fine-tunes local precipitation P (error 1℃→0.45℃). Cross-node collaboration takes less than 3 seconds per round, reducing the computation time from the traditional 72 hours to 20 minutes, an improvement of about 200 times. Robustness is enhanced (error is still <0.5℃ in noisy environments), enabling efficient processing of PB-level data, supporting ultra-large-scale cluster applications, and meeting the real-time requirements of climate research.

[0154] In summary, this case study validates the generality of the method through climate model calibration. High accuracy (0.45℃) is achieved through adaptive adjustment of dynamic physical constraints, while multi-scale parallel construction and collaborative optimization significantly improve efficiency (20 minutes). The cluster of 20,000 CPUs demonstrates excellent scalability. Compared to traditional methods, this method offers significant advantages in accuracy, speed, and adaptability.

[0155] It should be noted that, in this document, relational terms such as "first" and "second" are used merely to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising a reference structure" does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes the element.

[0156] 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 model correction method supporting large-scale parallel computation, characterized by: The method comprises the following steps: Sp1: data slicing and dynamic physical constraint initialization: preprocessing and dynamically slicing large-scale input data, distributing to multiple parallel computing nodes, adaptively generating initial constraint conditions of the physical model based on data distribution characteristics, and sharing constraints among nodes through a synchronization mechanism; Sp2: multi-scale parallel model construction and preliminary prediction: constructing a multi-scale model based on dynamic physical constraints on each computing node, including a coarse-grained global model and a fine-grained local model, and generating a preliminary prediction result in parallel, and integrating the prediction results through distributed memory sharing; Sp3: multi-scale error feedback and cross-node collaborative evaluation: comparing the preliminary prediction result with the measured value, calculating the multi-scale error, dynamically adjusting the error weight using a cross-node collaborative mechanism, and adaptively adjusting the correction granularity according to the local error by each node, and coordinating and optimizing the direction according to the global error by the master node; Sp4: adaptive constraint adjustment and distributed iterative correction: dynamically adjusting the physical constraint based on multi-scale error feedback, performing iterative correction in parallel on each node, updating parameters through asynchronous parallel optimization algorithm until the error converges; Sp5: global model integration and scalability verification: integrating the correction results of each node to generate a global correction model, and verifying its scalability by simulating different data sizes and conditions; Sp6: output optimization model and industrial application packaging: output the final correction model, provide adaptive parallel interface to support dynamic configuration of computing resources, and generate performance report. 2.The model correction method supporting large-scale parallel computing according to claim 1, characterized in that: The data slicing and dynamic physical constraint initialization includes denoising and standardization processing of input data to generate structured data, dynamically determining the slicing granularity and number according to the statistical characteristics of the data, and generating initial constraint conditions based on adaptive algorithms with physical meaning, and realizing constraint synchronization among nodes through message passing interface. 3.The model correction method supporting large-scale parallel computing according to claim 1, characterized in that: In the multi-scale parallel model construction and preliminary prediction, a coarse-grained global model is constructed based on simplified physical equations to capture global trends, and a fine-grained local model is constructed based on high-resolution physical simulation to optimize local precision, each node calculates the prediction values of coarse-grained and fine-grained models in parallel according to the allocated data slices, and integrates multi-scale prediction results among nodes through distributed memory sharing technology.

4. The model correction method for supporting massive parallel computation according to claim 1, characterized in that: In the multi-scale error feedback and cross-node collaborative evaluation, the preliminary prediction result is compared with the measured value to calculate the global error and the local error, the error weight is dynamically adjusted through the cross-node collaborative mechanism of distributed gradient aggregation, the master node performs real-time optimization coordination based on the global error and generates a correction direction broadcast to each node.

5. The model correction method for supporting massive parallel computation according to claim 1, characterized in that: In the adaptive constraint adjustment and distributed iterative correction, the error variation trend is used to dynamically adjust the physical constraint range according to the multi-scale error feedback, the support vector regression or Bayesian optimization method is used to predict the optimal direction of constraint adjustment, and the adjusted constraint is updated among nodes to ensure the consistency of iterative correction.

6. The model correction method for supporting massive parallel computation according to claim 1, characterized in that: The adaptive constraint adjustment and asynchronous parallel optimization algorithm in distributed iterative correction includes parameter update by asynchronous stochastic gradient descent or alternating direction method of multipliers, local optimization by each node independently and global parameter aggregation by the master node periodically, and setting the convergence condition as global error less than a preset threshold or iteration number reaching an upper limit.

7. The model correction method for supporting massive parallel computation according to claim 1, characterized in that: The global model integration and scalability verification utilize a distributed file system to store correction results of each node, and synthesize a global correction model by the master node, perform scalability verification through multiple test cases with simulated data scales varying from GB to TB, and verify indicators including model accuracy, calculation time and parallel efficiency and meet predefined performance standards.

8. The model correction method for supporting massive parallel computation according to claim 1, characterized in that: The output optimization model and adaptive parallel interface in industrial application packaging include providing a configured parallel node number parameter, supporting mainstream parallel computing frameworks, and packaging the interface as a modular component to support seamless integration with industrial production systems.

Images