Transfer Learning for Vehicle Vibroacoustic FE Surrogates

Why Full-Vehicle Vibroacoustic Finite Element Simulations Hit a Compute Wall

The problem runs deeper than it first appears. Since Gladwell’s foundational work in 1964, automotive engineers have known that passenger comfort hinges on controlling Noise, Vibration, and Harshness (NVH) across the low-to-mid frequency spectrum. In the early stages of vehicle body development, physical prototypes do not exist yet, forcing acoustic engineers to rely on massive finite element (FE) simulations of the body-in-white (the welded sheet-metal structure before painting and final assembly).

Consider the scale of the production meshes used at BMW Group and detailed in Section 2.1 of the paper:

• Source Vehicle — BMW X3 (Development Code G01): A Sports Activity Vehicle (SAV) whose production started in 2017, modeled with 3.1 million nodes and 2.6 million elements.
• Target Vehicle 1 — BMW X3 (Development Code G45): The direct SAV successor to the G01, entering production in 2024 with a substantially denser mesh of 6.1 million nodes and 5.5 million elements.
• Target Vehicle 2 — BMW 3 Series (Development Code G20): A passenger sedan whose production started in 2019, modeled with 2.3 million nodes and 1.8 million elements.

If a body-in-white behaved as a single deterministic structure, running one harmonic frequency response analysis might be manageable. In reality, a vehicle body is coupled to dozens of attached components—seats, dashboard, center console, bonnet, headlights, and doors—whose mounting stiffnesses vary due to production tolerances and trim configurations. In the finite element model, these attached subsystems are simplified to lumped-mass “minimized parts” connected to the body-in-white via elastic spring elements. Through prior sensitivity analysis, Cram et al. identified the 14 most sensitive connection stiffness parameters: two at the driver’s seat, six at the passenger seat, two at the center console, and one each at the headlights, dashboard, bonnet, and rear left door.

To quantify how uncertainties across those 14 stiffnesses alter the structural vibration propensity at the gearbox mount (“gearbox mount heave” excitation), engineers must evaluate thousands of Latin-hypercube parameter combinations across the 20 Hz to 100 Hz frequency band (discretized into 401 frequency points at 0.2 Hz steps). Executing a single full finite element run requires 3,879 seconds (roughly 1.1 hours) on a 64-CPU, 512 GB RAM compute node. Even when engineers apply Craig-Bampton dynamic substructuring (superelement reduction)—which invests 4,716 seconds (1.3 hours) on a 64-CPU, 910 GB RAM machine to condense the unchanging body-in-white so each subsequent parameter variation runs in 6 seconds—simulating 100,000 parameter variants still takes 604,716 seconds, or 168 hours (seven full days) of nonstop cluster time for a single vehicle.

Why Neural Surrogates Need Transfer Learning Across Vehicle Generations

To replace those 168-hour simulation campaigns with millisecond inference during interactive design optimization, engineers train surrogate models—ranging from Kriging (Gaussian Processes) and Polynomial Chaos Expansion to Artificial Neural Networks. While Multilayer Perceptrons (MLPs) handle 14-dimensional inputs and 401-dimensional frequency curves effortlessly at inference time, training an accurate MLP from scratch requires up to 100,000 FE simulations. If you must run 100,000 simulations for every new car model anyway just to train its surrogate, the surrogate has not saved you any upfront simulation time.

That paradox is exactly what motivates the TUM and BMW Group study in Engineering Applications of Artificial Intelligence. Rather than training a new neural surrogate from scratch for the 2024 BMW X3 (G45) or the BMW 3 Series (G20), can we take a Multilayer Perceptron already pre-trained on the 2017 BMW X3 (G01) and adapt it to the new vehicles using only 5,000 simulations? For readers following our coverage in the Engineering AI research hub and our analyses of parameter-efficient adaptation such as Rein++ for foundation models, this study provides a rare benchmark on industrial production FE meshes rather than toy academic problems.

Mathematical Formulations of Admittance, Evaluation Metrics, and L2-SP Transfer

Let us examine the exact physical and mathematical quantities governing the surrogate model. In structural vibroacoustics, the mechanical admittance \(Y_{kl}(\omega)\) in the frequency domain links a harmonic force excitation \(F_l(\omega)\) applied at coordinate \(x_l\) to the resulting structural velocity response \(v_k(\omega)\) measured at coordinate \(x_k\) across angular frequency \(\omega = 2\pi f\) (Equation 1 of the paper).

When measurement and excitation share the exact same coordinate and direction (\(k = l\), specifically vertical heave at the gearbox mount), \(Y_{kk}(\omega)\) is termed the mechanical point admittance (measured in \(\text{mm}/(\text{N}\cdot\text{s})\)), which characterizes how easily the chassis yields to vibrational energy injection.

To evaluate how well a Multilayer Perceptron predicts the 401-point admittance vector \(X_i\) against the finite element ground truth \(Y_i\) (with mean \(\bar{Y}\)) across \(N\) samples, the authors combine two global correlation metrics—the coefficient of determination \(R^2\) (Equation 2) and the Frequency Response Assurance Criterion \(\text{FRAC}\) (Equation 3)—with Normalized Mean Squared Error (\(\text{NMSE}\), in percent) and two localized physical feature metrics evaluated strictly in the critical 20 Hz to 70 Hz design window: Resonance Frequency Error (in Hz) and Peak Amplitude Error (in percent).

Why restrict Resonance Frequency Error and Peak Amplitude Error to 20–70 Hz when the simulation runs up to 100 Hz? Because above 70 Hz, the point admittance curves of all three vehicles exhibit a steep, monotonically ascending branch (Figure 7) that would artificially dominate peak-picking algorithms and mask true structural resonance shifts in the 30–68 Hz band.

Network-Based Transfer Learning with L2-SP Anchored Regularization

Following the taxonomy of Pan and Yang (2010) and Tan et al. (2018)—which divides transfer learning into instance-based, mapping-based, adversarial-based, and network-based strategies—the authors adopt network-based transfer learning because it avoids storing or re-processing the 100,000 source domain samples during target fine-tuning. However, standard fine-tuning on a small 5,000-sample target dataset risks either catastrophic forgetting of the pre-trained representations or severe overfitting.

To prevent both failure modes, Cram et al. combine three architectural mechanisms during fine-tuning (illustrated in Figures 6 and 10):

1. Progressive Early-Layer Freezing: An initial contiguous segment of hidden layers \(A_n = \{1, \dots, n\}\) (such as layers \([1, 2]\) or \([1, 2, 3]\)) has its weights and biases completely frozen (\(\Delta W = 0\)) to preserve general low-level stiffness-to-modal feature interactions.
2. L2-SP Anchored Regularization on Unfrozen Pre-Trained Layers: For the remaining unfrozen layers inherited from the source G01 network, parameter updates \(\theta\) are tethered to their pre-trained initialization values \(\theta_0\) using the explicit inductive bias penalty of Li et al. (2018) (Equation 4), where \(\tilde{\mathcal{L}}(\theta)\) is the Huber data loss and \(\alpha\) is the regularization strength.
3. Task-Specific Newly Appended Layers: Between 2 and 4 freshly initialized hidden layers of matching width are inserted immediately before the 401-node output head to learn target-vehicle modal shifts.

Hyperparameter Optimization via Tree-Structured Parzen Estimator

Both pre-training (up to 200 trials, max 500 epochs with early stopping) and fine-tuning (up to 150 trials, max 100 epochs with 5-fold cross-validation on the 90 percent training split and a held-out 10 percent test split) were optimized using Bayesian Tree-structured Parzen Estimators (TPE) in `Hyperopt 0.2.7` on an NVIDIA RTX A4000 (16 GB) workstation. Tables 3 and 4 of the paper reveal how data volume shapes the optimal network topology:

Notice the consistent patterns in Table 1 above. Across every single pre-training and fine-tuning run, Bayesian optimization selected the Adam optimizer over SGD and the Huber loss over MSE and MAE, leveraging Huber’s quadratic behavior near zero and linear robustness against resonant amplitude outliers. Furthermore, when transferring from the 100,000-sample G01 model (500 neurons wide), the G20 sedan freezes three layers (\([1, 2, 3]\)) whereas the G45 SAV freezes two (\([1, 2]\)), and both append 3 new layers for a total depth of 10. When transferring from the smaller 20,000-sample G01 model (200 neurons wide), TPE compensates for the weaker source features by freezing only the first layer (\([1]\)) and appending 4 new layers for a total depth of 11.

Experimental Benchmarks and Compute Savings Across BMW Platforms

To establish a rigorous baseline on the held-out 10 percent test sets, the authors first evaluated the pre-trained G01 models on their native G01 test split: the 100,000-sample model achieves \(R^2 = 0.99\), \(\text{FRAC} = 0.98\), \(\text{NMSE} = 0.02\%\), a resonance frequency error of \(1.5\text{ Hz}\), and a peak amplitude error of \(1.7\%\); the 20,000-sample G01 model achieves \(R^2 = 0.92\), \(\text{FRAC} = 0.91\), \(\text{NMSE} = 0.11\%\), a resonance frequency error of \(3.6\text{ Hz}\), and a peak amplitude error of \(4.2\%\). They then compared five distinct modeling regimes on the target G45 and G20 vehicles (Figure 11):

Examine the numbers in Table 2 above. Training a Multilayer Perceptron from scratch on 5,000 target samples (`only G45 / G20 data`) falls well short of the \(R^2 \ge 0.90\) engineering threshold required for reliable NVH design, stalling at \(0.74\) on G45 (with an \(8.5\text{ Hz}\) resonance error and \(10.1\%\) amplitude error) and \(0.77\) on G20 (\(7.2\text{ Hz}\) resonance error and \(10.7\%\) amplitude error). Initializing with the 100k G01 network and applying L2-SP fine-tuning on those exact same 5,000 samples propels \(R^2\) to 0.93 on G45 and 0.95 on G20, cutting NMSE by more than threefold (to \(0.2\%\) and \(0.1\%\)) and slashing G20 resonance frequency error from \(7.2\text{ Hz}\) down to \(2.2\text{ Hz}\).

“It is worth noting that with transfer learning, four Multilayer Perceptrons achieved good performance and each of them requires about 75% (small data set) to 95% (large data set) less data than training without fine-tuning. Furthermore, it was shown that the used transfer learning approach leads to a reduction in computational time.”

Sophie Cram, Marinus Luegmair, Jiale Yu, Marcus Maeder, and Steffen Marburg, Engineering Applications of Artificial Intelligence (2026)

Why Did the 2017 X3 Transfer Better to the 2019 3 Series Sedan Than to the 2024 X3?

One of the most fascinating findings in Section 7 is a seeming paradox: the BMW G01 and BMW G45 are both Sports Activity Vehicles (X3), whereas the BMW G20 is a lower-slung 3 Series sedan. Why did transfer learning from G01 achieve a higher \(R^2\) on the G20 sedan (\(0.95\) vs \(0.93\) for large source data, and \(0.89\) vs \(0.86\) for small source data) and freeze three layers (\([1, 2, 3]\)) instead of two (\([1, 2]\))?

The answer lies in platform generation timelines rather than exterior body styling. Production of the G01 started in 2017 and the G20 followed just two years later in 2019, meaning both vehicles shared closely aligned body-in-white structural design concepts and manufacturing joining techniques. As Figure 7 confirms, the mean and standard deviation curves of the G01 and G20 point admittances track each other closely across the entire 20–100 Hz spectrum (featuring twin resonance peaks near 35 Hz, 57 Hz, and 67 Hz). By contrast, the G45 launched in 2024—seven years after the G01—incorporating updated body architecture and manufacturing concepts that shift its admittance distribution between 35 Hz and 50 Hz. Achieving \(R^2 = 0.93\) across a seven-year engineering gap underscores the resilience of the L2-SP fine-tuning pipeline.

Wall-Clock Compute Time Savings

In Section 6.4, the authors sum the wall-clock time required to generate 5,000 target superelement simulations (\(34,716\text{ s} \approx 9.6\text{ h}\)), pre-train the G01 source network (\(60,568\text{ s} \approx 16.8\text{ h}\) for 100k, or \(15,515\text{ s} \approx 4.3\text{ h}\) for 20k), and run the 150-trial Bayesian fine-tuning sweep:

• Large Pre-Trained Basis (100k G01 → 5k Target): Total time is \(34,716\text{ s} + 60,568\text{ s} + 37,249\text{ s} = 132,533\text{ s} \approx 36.8\text{ hours}\) for G45, and \(34,716\text{ s} + 60,568\text{ s} + 26,455\text{ s} = 121,739\text{ s}\) (reported as \(131,739\text{ s} \approx 36.6\text{ hours}\)) for G20—compared to \(604,716\text{ s} \approx 168\text{ hours}\) to simulate 100,000 target variants from scratch (a 4.5-fold speedup even when counting one-time source pre-training, and a 12.9-fold speedup once the pre-trained G01 model is amortized across subsequent vehicle derivatives).
• Small Pre-Trained Basis (20k G01 → 5k Target): Total time is \(34,716\text{ s} + 15,515\text{ s} + 67,495\text{ s} = 117,726\text{ s} \approx 32.7\text{ hours}\) for G45 and \(34,716\text{ s} + 15,515\text{ s} + 62,266\text{ s} = 112,497\text{ s} \approx 31.2\text{ hours}\) for G20, beating the \(124,716\text{ s} \approx 34.6\text{ hours}\) needed to simulate 20,000 variants even before amortizing the source model.

Honest Limitations and Future Directions Toward Graph Neural Networks

In Sections 7 and 8, Cram and colleagues candidly outline the boundaries of their approach and where automotive AI surrogates must go next:

1. Single-OEM, Shared-Parameter, Single-Load-Case Scope: All three vehicles belong to BMW Group, share the exact same 14 stiffness parameter definitions, and are evaluated on a single excitation load case (`gearbox mount heave`). If a target vehicle uses a radically different chassis concept (for example, a carbon-fiber monocoque or body-on-frame truck where the causal transfer paths become linear or topologically disjoint), MLP fine-tuning will not transfer effectively.
2. Lack of Spatial Topology Awareness in Flat MLPs: A standard Multilayer Perceptron treats the 14 input stiffnesses as an unordered flat vector \(x \in \mathbb{R}^{14}\), ignoring the 3D Euclidean distances between the driver’s seat, passenger seat, dashboard, and gearbox mount. In their outlook, the authors highlight extending the surrogate to spatially aware Distance-assisted Graph Neural Networks (GNNs)—a direction that connects directly to our analyses of graph-based spatial reasoning in G2RA-Net and isogeometric structural mechanics.
3. Instance-Based Ensemble Alternatives: Future work will benchmark network-based L2-SP fine-tuning against instance-based boosting algorithms such as two-stage `TrAdaBoost.R2` and multi-load-case transfer.

Conclusion

By demonstrating transfer learning across three multi-million-node production finite element models from BMW’s vehicle lineup, Cram, Luegmair, Yu, Maeder, and Marburg have closed a major gap between academic machine learning and industrial NVH engineering. Their work proves that while a pre-trained vibroacoustic neural network fails completely in zero-shot inference on a new car body (\(R^2 < 0\)), its early hidden layers encode reusable physical representations of how component attachment stiffnesses modulate structural resonances.

Unlocking those representations requires a disciplined three-part recipe: freezing the earliest feature layers, tethering intermediate layers to their source weights via L2-SP anchored regularization (\(\frac{\alpha}{2}\|\theta – \theta_0\|_2^2\)), and appending fresh hidden layers tuned with the Huber loss. That combination turns a 5,000-sample target dataset from a mediocre \(R^2 = 0.74\text{–}0.77\) model into a production-grade \(R^2 = 0.93\text{–}0.95\) surrogate, eliminating up to 95,000 finite element runs per vehicle derivative.

As automotive engineering teams increasingly amortize a single pre-trained foundation surrogate across entire families of electric and combustion vehicle platforms, combining L2-SP network transfer with spatially aware Graph Neural Networks will make real-time, uncertainty-aware acoustic optimization a standard part of early concept design.

Complete PyTorch Implementation of L2-SP Vibroacoustic Transfer Learning

Below is a complete, self-contained, runnable PyTorch implementation of the exact vibroacoustic transfer learning pipeline described in Sections 3, 4, and 5 of the paper, including the 7-layer source Multilayer Perceptron (`VibroacousticMLP`, 14 inputs to 401 frequency points), the `TransferVibroacousticMLP` module that freezes layers \(A_n = \{1, \dots, n\}\), applies explicit **L2-SP anchored regularization** (Equation 4) to unfrozen source layers, and appends newly added layers (Figure 10), alongside the exact evaluation metrics—\(R^2\) (Equation 2), complex/real **FRAC** (Equation 3), **NMSE %**, **Resonance Frequency Error (20–70 Hz)**, and **Peak Amplitude Error % (20–70 Hz)**—verified via a runnable smoke test.

import copy
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import TensorDataset, DataLoader

# =====================================================================
# 1. ACTIVATION FACTORY & PRE-TRAINED G01 MULTILAYER PERCEPTRON (FIG. 9)
# =====================================================================

def get_activation(name: str) -> nn.Module:
    """Returns activation module from hyperparameter search space (Table 3 & 4)."""
    mapping = {
        "relu": nn.ReLU(),
        "elu": nn.ELU(),
        "tanh": nn.Tanh(),
        "swish": nn.SiLU(),  # Swish (Ramachandran et al., 2017)
    }
    return mapping[name.lower()]


class VibroacousticMLP(nn.Module):
    """
    Implements Section 5.2.1 (Fig. 9 & Table 3):
    7-layer Multilayer Perceptron mapping 14 component stiffness parameters
    through 6 hidden layers (width 500 for large G01, 200 for small G01)
    to 401 frequency-domain point admittance values (20 Hz to 100 Hz).
    """
    def __init__(
        self,
        in_features: int = 14,
        out_features: int = 401,
        width: int = 500,
        num_hidden: int = 6,
        activation: str = "swish"
    ):
        super().__init__()
        self.in_features = in_features
        self.out_features = out_features
        self.width = width
        self.num_hidden = num_hidden

        self.hidden_layers = nn.ModuleList()
        in_dim = in_features
        for _ in range(num_hidden):
            layer = nn.Sequential(
                nn.Linear(in_dim, width),
                get_activation(activation)
            )
            self.hidden_layers.append(layer)
            in_dim = width

        self.output_head = nn.Linear(width, out_features)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        h = x
        for layer in self.hidden_layers:
            h = layer(h)
        return self.output_head(h)


# =====================================================================
# 2. NETWORK-BASED TRANSFER MLP WITH L2-SP REGULARIZATION (FIG. 10)
# =====================================================================

class TransferVibroacousticMLP(nn.Module):
    """
    Implements Section 3.4 & Section 5.2.2 (Fig. 10 & Table 4):
    - Freezes initial hidden layers [1, ..., n_frozen] (Delta W = 0).
    - Applies L2-SP anchored regularization (Eq. 4) to unfrozen pre-trained layers
      to penalize deviation from source weights theta_0.
    - Appends `num_added` new hidden layers of matching width before the 401-output head.
    """
    def __init__(
        self,
        pretrained_mlp: VibroacousticMLP,
        n_frozen: int = 3,
        num_added: int = 3,
        added_activation: str = "swish"
    ):
        super().__init__()
        self.width = pretrained_mlp.width
        self.out_features = pretrained_mlp.out_features
        self.n_frozen = n_frozen

        # Copy pre-trained hidden layers from source G01 network
        self.pretrained_layers = copy.deepcopy(pretrained_mlp.hidden_layers)

        # Freeze layers in A_n = {1, ..., n_frozen} (0-indexed: 0 to n_frozen - 1)
        for idx in range(n_frozen):
            for param in self.pretrained_layers[idx].parameters():
                param.requires_grad = False

        # Store frozen snapshot theta_0 of unfrozen pre-trained layers for L2-SP (Eq. 4)
        self.theta_0 = {}
        for idx in range(n_frozen, len(self.pretrained_layers)):
            for name, param in self.pretrained_layers[idx].named_parameters():
                key = f"layer_{idx}_{name}"
                self.theta_0[key] = param.detach().clone()

        # Append newly added target-domain hidden layers (3 for large, 4 for small)
        self.added_layers = nn.ModuleList()
        for _ in range(num_added):
            self.added_layers.append(
                nn.Sequential(
                    nn.Linear(self.width, self.width),
                    get_activation(added_activation)
                )
            )

        # Final 401-point admittance output layer
        self.output_head = nn.Linear(self.width, self.out_features)

    def compute_l2_sp_penalty(self, alpha: float = 1e-3) -> torch.Tensor:
        """Implements Equation (4) penalty: (alpha / 2) * ||theta - theta_0||_2^2."""
        l2_sp = torch.tensor(0.0, device=next(self.parameters()).device)
        for idx in range(self.n_frozen, len(self.pretrained_layers)):
            for name, param in self.pretrained_layers[idx].named_parameters():
                ref_w = self.theta_0[f"layer_{idx}_{name}"].to(param.device)
                l2_sp = l2_sp + torch.sum((param - ref_w) ** 2)
        return 0.5 * alpha * l2_sp

    def get_relative_layer_weight_changes(self) -> dict:
        """Computes relative L2 weight change % per unfrozen pre-trained layer (Fig. 12)."""
        stats = {}
        for idx in range(self.n_frozen, len(self.pretrained_layers)):
            w_curr = self.pretrained_layers[idx][0].weight.detach()
            w_init = self.theta_0[f"layer_{idx}_0.weight"].to(w_curr.device)
            rel_l2 = (torch.norm(w_curr - w_init) / (torch.norm(w_init) + 1e-12)).item() * 100.0
            stats[f"Layer_{idx + 1}"] = rel_l2
        return stats

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        h = x
        for layer in self.pretrained_layers:
            h = layer(h)
        for layer in self.added_layers:
            h = layer(h)
        return self.output_head(h)


# =====================================================================
# 3. VIBROACOUSTIC EVALUATION METRICS (SECTION 3.2 & SECTION 4.1)
# =====================================================================

def evaluate_vibroacoustic_metrics(
    pred: torch.Tensor,
    target: torch.Tensor,
    freqs_hz: torch.Tensor
) -> dict:
    """
    Computes R^2 (Eq. 2), FRAC (Eq. 3), NMSE %, and 20-70 Hz Resonance Frequency
    Error (Hz) and Peak Amplitude Error (%) across test curves.
    """
    # 1. Global Coefficient of Determination R^2 (Eq. 2)
    y_mean = torch.mean(target, dim=0, keepdim=True)
    ss_res = torch.sum((pred - target) ** 2)
    ss_tot = torch.sum((target - y_mean) ** 2).clamp(min=1e-12)
    r2_score = (1.0 - (ss_res / ss_tot)).item()

    # 2. Frequency Response Assurance Criterion FRAC (Eq. 3)
    num = torch.abs(torch.sum(pred * torch.conj(target), dim=-1)) ** 2
    den = (torch.sum(torch.abs(pred) ** 2, dim=-1) * torch.sum(torch.abs(target) ** 2, dim=-1)).clamp(min=1e-12)
    frac_score = torch.mean(num / den).item()

    # 3. Normalized Mean Squared Error NMSE (%)
    nmse_pct = (ss_res / torch.sum(target ** 2).clamp(min=1e-12)).item() * 100.0

    # 4. Resonance Frequency Error (Hz) & Peak Amplitude Error (%) in 20-70 Hz window
    mask_20_70 = (freqs_hz >= 20.0) & (freqs_hz <= 70.0)
    f_sub = freqs_hz[mask_20_70]
    p_sub = pred[:, mask_20_70]
    t_sub = target[:, mask_20_70]

    p_peak_val, p_peak_idx = torch.max(p_sub, dim=-1)
    t_peak_val, t_peak_idx = torch.max(t_sub, dim=-1)

    res_freq_err_hz = torch.mean(torch.abs(f_sub[p_peak_idx] - f_sub[t_peak_idx])).item()
    peak_amp_err_pct = torch.mean(torch.abs(p_peak_val - t_peak_val) / t_peak_val.clamp(min=1e-8)).item() * 100.0

    return {
        "R2": r2_score,
        "FRAC": frac_score,
        "NMSE_%": nmse_pct,
        "ResFreqErr_Hz": res_freq_err_hz,
        "PeakAmpErr_%": peak_amp_err_pct,
    }


# =====================================================================
# 4. SYNTHETIC MODAL ADMITTANCE GENERATOR & RUNNABLE SMOKE TEST
# =====================================================================

def simulate_vehicle_admittance_dataset(
    num_samples: int,
    freqs_hz: torch.Tensor,
    base_modes_hz=(34.5, 56.5, 67.0),
    modal_shift: float = 0.0,
    amp_scale: float = 1.0,
    device="cpu"
):
    """
    Synthesizes 14 Latin-like normalized stiffness parameters and 401-point
    mechanical point admittance curves (20-100 Hz) mimicking Fig. 7.
    """
    x_stiff = torch.rand(num_samples, 14, device=device)
    f = freqs_hz.unsqueeze(0)  # [1, 401]

    # Stiffness parameters modulate modal resonance frequencies and damping
    f1 = base_modes_hz[0] + modal_shift + 4.0 * (x_stiff[:, 0:1] - 0.5)
    f2 = base_modes_hz[1] + modal_shift + 5.0 * (x_stiff[:, 1:2] - 0.5)
    f3 = base_modes_hz[2] + modal_shift + 3.5 * (x_stiff[:, 2:3] - 0.5)

    g1 = 0.025 * (1.0 + 0.3 * x_stiff[:, 3:4]) / (((f - f1) / 3.2) ** 2 + 1.0)
    g2 = 0.032 * (1.0 + 0.3 * x_stiff[:, 4:5]) / (((f - f2) / 6.5) ** 2 + 1.0)
    g3 = 0.020 * (1.0 + 0.2 * x_stiff[:, 5:6]) / (((f - f3) / 3.0) ** 2 + 1.0)

    # Ascending high-frequency branch above 70 Hz as shown in Fig. 7
    ascending_branch = 0.012 + 0.055 * ((f - 20.0) / 80.0) ** 1.35
    stiff_mod = 0.004 * (x_stiff[:, 6:] @ torch.linspace(-1.0, 1.0, 8, device=device).unsqueeze(1))

    y_admittance = amp_scale * (ascending_branch + g1 + g2 + g3 + stiff_mod)
    return x_stiff, y_admittance


if __name__ == "__main__":
    torch.manual_seed(42)
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    freqs = torch.linspace(20.0, 100.0, 401, device=device)

    # 1. Generate Source (BMW G01) and Shifted Target (BMW G20) Datasets
    x_src, y_src = simulate_vehicle_admittance_dataset(1024, freqs, modal_shift=0.0, amp_scale=1.0, device=device)
    x_tgt, y_tgt = simulate_vehicle_admittance_dataset(256, freqs, modal_shift=3.5, amp_scale=1.18, device=device)

    # 2. Pre-train Source G01 Model (Width=500, Depth=7, Swish, Adam, Huber Loss, lr=1e-3)
    source_model = VibroacousticMLP(in_features=14, out_features=401, width=500, num_hidden=6, activation="swish").to(device)
    opt_src = torch.optim.Adam(source_model.parameters(), lr=1e-3)
    huber_loss = nn.HuberLoss()

    src_loader = DataLoader(TensorDataset(x_src, y_src), batch_size=128, shuffle=True)
    source_model.train()
    for _ in range(25):
        for bx, by in src_loader:
            opt_src.zero_grad()
            loss = huber_loss(source_model(bx), by)
            loss.backward()
            opt_src.step()

    # Evaluate Zero-Shot Transfer on Target Vehicle (No Fine-Tuning)
    source_model.eval()
    with torch.no_grad():
        zero_shot_metrics = evaluate_vibroacoustic_metrics(source_model(x_tgt), y_tgt, freqs)

    # 3. Fine-Tune on Target Vehicle (G20 Config: Freeze [1,2,3], L2-SP on [4,5,6], +3 Added Layers, lr=1e-4)
    transfer_model = TransferVibroacousticMLP(
        source_model, n_frozen=3, num_added=3, added_activation="swish"
    ).to(device)

    trainable_params = [p for p in transfer_model.parameters() if p.requires_grad]
    opt_ft = torch.optim.Adam(trainable_params, lr=1e-4)
    tgt_loader = DataLoader(TensorDataset(x_tgt[:200], y_tgt[:200]), batch_size=16, shuffle=True)

    transfer_model.train()
    for _ in range(35):
        for bx, by in tgt_loader:
            opt_ft.zero_grad()
            pred = transfer_model(bx)
            # Equation (4): Huber Loss + L2-SP Anchored Regularization
            loss_ft = huber_loss(pred, by) + transfer_model.compute_l2_sp_penalty(alpha=1e-4)
            loss_ft.backward()
            opt_ft.step()

    transfer_model.eval()
    with torch.no_grad():
        ft_metrics = evaluate_vibroacoustic_metrics(transfer_model(x_tgt[200:]), y_tgt[200:], freqs)

    print(f"Zero-Shot Transfer -> R2: {zero_shot_metrics['R2']:.3f} | FRAC: {zero_shot_metrics['FRAC']:.3f} | ResErr: {zero_shot_metrics['ResFreqErr_Hz']:.2f} Hz")
    print(f"L2-SP Fine-Tuned   -> R2: {ft_metrics['R2']:.3f} | FRAC: {ft_metrics['FRAC']:.3f} | ResErr: {ft_metrics['ResFreqErr_Hz']:.2f} Hz")
    print("Unfrozen Layer Relative Weight Changes (%):", transfer_model.get_relative_layer_weight_changes())

Frequently Asked Questions

Related Research Analyses on aitrendblend.com