3. Surrogate modeling with machine learning for restraint system response prediction

In restraint calibration, every candidate design must be evaluated against occupant injury criteria such as HIC, chest deflection, neck tension, and femur load. Running a full finite element (FE) sled simulation for each candidate is accurate but expensive: a single LS-DYNA or PAM-CRASH run may take 30–120 minutes on a multi-core workstation. When a calibration study spans hundreds or thousands of design points across airbag pressure, vent size, seatbelt load limiter force, pretensioner timing, and seat geometry, direct simulation becomes impractical. Surrogate modeling solves this by learning a fast, cheap approximation of the simulation response from a limited set of training runs.

This chapter covers three families of surrogate models that dominate restraint calibration practice: Gaussian processes (GPs), neural networks (NNs), and ensemble methods. The goal is not to replace the FE model but to build a response surface accurate enough to guide optimization, then verify the best candidates with full simulation.

Why Surrogates Are Necessary in Restraint Calibration

A typical restraint calibration problem has 6–15 design variables and 4–10 response outputs. The design space is non-linear and often discontinuous: airbag venting, belt slip, and contact interactions create sharp transitions in occupant response. A surrogate must capture these transitions without requiring thousands of simulations. The trade-off is explicit: fewer training runs means faster model construction, but higher risk of missing a critical response peak.

The standard workflow is: design of experiments (DOE) sampling → FE simulation batch → surrogate training → validation → optimization on the surrogate → FE verification of top candidates. The surrogate is only as good as its training data, so sampling strategy and validation discipline matter as much as model choice.

Gaussian Process Regression

A Gaussian process defines a distribution over functions. For a response y(x) at design point x, the GP assumes that any finite set of outputs follows a multivariate normal distribution defined by a mean function m(x) and a covariance kernel k(x, x'). The most common kernel in restraint work is the squared exponential (RBF) kernel:

k(x, x') = σ_f² · exp( -0.5 · Σ_i ( (x_i - x'_i)² / ℓ_i² ) ) + σ_n² · δ(x, x')

Here σ_f² is the signal variance, ℓ_i is the length scale for each design variable, and σ_n² is the noise variance. The length scales are critical: a short ℓ_i means the response changes rapidly along that variable, which is typical for vent size or pretensioner timing.

GP prediction at a new point x* returns a mean and a variance. The variance is a built-in uncertainty estimate, which is extremely useful in calibration: you can trust predictions with low variance and simulate points with high variance. This makes GPs the preferred choice when the simulation budget is tight (e.g., 50–150 runs).

Practical implementation in Python with scikit-learn:

from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, WhiteKernel, ConstantKernel

kernel = ConstantKernel(1.0) * RBF(length_scale=[1.0]*8) + WhiteKernel(noise_level=1e-3)
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10, normalize_y=True)
gp.fit(X_train, y_train)          # X_train: (n_samples, 8), y_train: (n_samples,)
y_pred, y_std = gp.predict(X_test, return_std=True)

After fitting, inspect gp.kernel_ to read the optimized length scales. If a length scale is very large, that variable has little effect on the response; if it is very small, the response is highly sensitive and the DOE should be denser in that dimension.

Neural Network Surrogates

Feedforward neural networks are attractive when the training set is larger (500+ runs) and the response surface is highly non-linear or high-dimensional. A typical architecture for restraint response prediction is a multilayer perceptron with 2–4 hidden layers, 64–256 neurons per layer, and ReLU or tanh activations. The output layer has one node per response (HIC, chest deflection, etc.), so a single network can predict multiple injury criteria simultaneously.

Key training considerations:

• Normalization: Scale inputs to zero mean and unit variance, and scale outputs similarly. Injury criteria span orders of magnitude (HIC ~ 100–2000, neck tension ~ 0.5–5 kN), so unscaled outputs cause unstable gradients.
• Loss function: Mean squared error is standard, but for calibration you may weight rare high-severity responses more heavily.
• Regularization: Dropout (0.1–0.3) and early stopping on a validation split prevent overfitting to the DOE points.
• Ensemble of networks: Train 5–10 networks with different random seeds and average their predictions. The spread across networks provides an uncertainty estimate similar to GP variance.

import torch
import torch.nn as nn

model = nn.Sequential(
    nn.Linear(8, 128), nn.ReLU(),
    nn.Dropout(0.2),
    nn.Linear(128, 128), nn.ReLU(),
    nn.Dropout(0.2),
    nn.Linear(128, 64), nn.ReLU(),
    nn.Linear(64, 4)          # 4 injury responses
)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.MSELoss()

NNs generally outperform GPs when the training set is large and the response is smooth but complex. However, they require more tuning and do not naturally provide calibrated uncertainty without extra machinery.

Ensemble Methods

Ensemble methods combine many weak learners to produce a robust predictor. In restraint calibration, the two most useful are Random Forests and Gradient Boosted Trees (XGBoost, LightGBM).

Random Forests build hundreds of decision trees on bootstrap samples and average their outputs. They handle mixed variable types, are robust to outliers, and provide feature importance rankings that reveal which design variables dominate each injury response. Gradient boosting builds trees sequentially, each correcting the previous model's residuals, and often achieves lower error than Random Forests on tabular DOE data.

from sklearn.ensemble import RandomForestRegressor

rf = RandomForestRegressor(n_estimators=500, max_depth=12,
                           min_samples_leaf=2, random_state=42)
rf.fit(X_train, y_train)
importances = rf.feature_importances_   # rank design variables

Ensembles are less effective for extrapolation beyond the DOE range and do not provide smooth gradients, which can complicate gradient-based optimization. They are best used for screening variables and for problems with irregular, noisy response surfaces.

Choosing and Validating a Surrogate

Model selection should be driven by training set size, response smoothness, and the need for uncertainty estimates. The table below summarizes the practical trade-offs.

Validation must use held-out FE runs, not training data. Report R² and normalized RMSE for each injury response separately, because a surrogate may predict HIC well but chest deflection poorly. A common acceptance threshold in restraint work is R² > 0.9 and normalized RMSE < 10% on a validation set of 20–30 runs. If a response fails validation, add DOE points near the region of high error, identified by GP variance or ensemble disagreement.

Workflow Summary

The figure below shows how the three surrogate families fit into the calibration loop, from DOE sampling through FE simulation, model training, validation, and final verification.

The loop is iterative: if validation error exceeds the threshold for any injury response, add DOE points in the high-error region and retrain. Once the surrogate passes validation, run optimization (genetic algorithm, Bayesian optimization, or gradient-based methods) on the surrogate to identify candidate designs, then verify the top candidates with full FE simulation. Only after FE verification should a calibration be considered complete.