Reading Time: 14 minutes

Multi-fidelity surrogate modeling is a framework that combines cheap, fast simulations with expensive, high-fidelity ground truth to achieve high accuracy at significantly lower computational cost. Rather than running expensive high-fidelity simulations for every design point, practitioners use low-fidelity models to establish a baseline and apply machine learning corrections to bridge the gap toward high-fidelity accuracy.

This approach matters because many engineering problems — aerodynamic shape optimization, composite material design, geological carbon storage assessment — require thousands of simulation runs. Running each one with a full high-fidelity model is impractical. Multi-fidelity surrogates offer a path to accurate predictions while reducing computational expense by orders of magnitude.

The core idea is simple: use whatever cheap simulations you have, calibrate them against whatever expensive data you can afford to collect, and let machine learning learn the discrepancy between them. The implementation landscape is rich — co-kriging (Bayesian Gaussian process fusion), neural operators (FNO, DeepONet, WNO), reduced-order surrogate modeling, and hybrid ML correction networks all offer distinct trade-offs.

Image suggestion: A fidelity hierarchy diagram showing LoFi (coarse grid, simplified physics) → HiFi (fine grid, full physics) → MF correction (ML layer bridging the gap). This diagram illustrates the core concept.

Key Takeaways

  • Multi-fidelity surrogate models combine cheap low-fidelity simulations with expensive high-fidelity data to achieve accuracy at lower cost, using machine learning to learn the discrepancy between fidelity levels.
  • Transfer learning is currently the most robust multi-fidelity neural operator strategy across test cases, consistently outperforming joint training architectures when the low-fidelity to high-fidelity discrepancy is large.
  • Multi-fidelity Kriging (co-kriging) has surprisingly narrow applicability conditions — correlation must exceed r² > 0.9 and the cheap-to-total budget ratio must fall between 0.1 and 0.8. Many practitioners attempt co-kriging without meeting these bounds.
  • The Python ecosystem for multi-fidelity modeling is fragmented but maturing — no single library covers the entire landscape, and practitioners need to combine multiple tools.
  • The hardest multi-fidelity problems involve governing-equation differences (RANS vs. LES) rather than simple grid coarsening, and direct low-fidelity incorporation strategies can degrade when discrepancies are large.

What Multi-Fidelity Means

A multi-fidelity surrogate model is a statistical or machine learning model that uses data from multiple sources of varying accuracy to predict system behavior. The term “fidelity” refers to the accuracy of the simulation — high-fidelity models (full Navier-Stokes, fine meshes, complex physics) are expensive but accurate, while low-fidelity models (simplified physics, coarse meshes, reduced-order models) are cheap but less accurate.

The multi-fidelity approach exploits the fact that cheaper simulations are often correlated with expensive ones. Even a qualitatively correct low-fidelity model can serve as a powerful prior for expensive high-fidelity data, dramatically improving sample efficiency compared to single-fidelity approaches.

Concrete Examples

Aerospace CFD optimization: Designing an airfoil shape requires hundreds of simulation runs. Running each one with a full Navier-Stokes solver on a fine grid might take minutes or hours per run. Running the same simulation with a potential-flow model (low-fidelity) takes seconds. A multi-fidelity surrogate learns the discrepancy between potential flow and Navier-Stokes accuracy, then predicts high-fidelity results using mostly cheap simulations with a few expensive validation points.

Composite materials modeling: Predicting the mechanical properties of a composite laminate under various loading conditions requires evaluating stress fields at multiple scales. Full 3D finite element analysis at the ply level is expensive. A layer-wise theory (low-fidelity) model runs much faster. Multi-fidelity surrogate modeling learns the relationship between the two, enabling rapid property prediction for design space exploration.

Geological carbon storage: Predicting CO₂ plume migration over decades requires solving multiphase flow equations. Fine-grid simulations with full thermodynamic coupling are prohibitively expensive for uncertainty quantification. Multi-fidelity approaches combine coarse-grid simulations (cheap) with select fine-grid runs (expensive) to build accurate surrogates for risk assessment.

These examples share a common pattern: many cheap simulations are available, a few expensive ones are feasible, and the cheap models are correlated with the expensive ones. The multi-fidelity surrogate exploits this structure.

When Multi-Fidelity Is Worth It

Multi-fidelity modeling adds complexity — you need to collect data from multiple sources, estimate correlations between fidelity levels, and use more sophisticated algorithms. It is not always the right choice.

Toal’s Conditions

The practical conditions identified by Toal (2015) under which multi-fidelity Kriging actually improves accuracy compared to single-fidelity approaches: These conditions are surprisingly narrow and are often overlooked in practice:

  1. Correlation threshold: The correlation between fidelity levels must satisfy r² > 0.9. If the low-fidelity model produces results that are only weakly correlated with the high-fidelity ground truth, the multi-fidelity approach can actually worsen predictions by introducing conflicting information.
  2. Budget fraction: The fraction of the total simulation budget allocated to cheap simulations should fall between 0.1 and 0.8. If you spend too much budget on cheap simulations and too few on expensive ones, the correction model cannot be properly calibrated. If you spend too little on cheap simulations, you cannot establish the baseline accurately.
  3. Conservative sample ratio: The number of cheap samples should exceed 1.75 times (1 + 1/Cr), where Cr is the correlation ratio between fidelity levels. This ensures sufficient data to learn the discrepancy function reliably.

When these conditions are met, multi-fidelity Kriging provides accuracy comparable to single-fidelity models that would require many more expensive samples. When they are not met, practitioners should reconsider whether multi-fidelity modeling is appropriate.

Cost-Benefit Analysis

Beyond Toal’s conditions, practical multi-fidelity adoption requires evaluating your specific constraints:

  • Simulation cost ratio: How much cheaper is the low-fidelity model? If the cost ratio is less than 10:1 (cheap simulation is less than 10% of expensive simulation cost), multi-fidelity modeling becomes attractive for problems requiring thousands of runs.
  • Available data: Do you already have legacy low-fidelity simulation data? Multi-fidelity modeling is particularly attractive when cheap historical data exists but no high-fidelity data has been collected.
  • Accuracy requirements: How much accuracy do you need for your application? For exploratory design space analysis, moderate accuracy may suffice. For final design validation, you need high-fidelity accuracy.
  • Computational budget: Can you afford hundreds of expensive simulations? If yes, single-fidelity approaches may be practical. If no, multi-fidelity is likely necessary.

The decision framework below summarizes these trade-offs:

Image suggestion: A cost-accuracy trade-off curve showing MF-Kriging achieving high accuracy at lower cost compared to HiFi-only, with the Toal conditions annotated. This diagram illustrates the cost-accuracy relationship.

When Single-Fidelity Might Be Sufficient

Single-fidelity surrogate modeling (described in our guide to machine learning surrogates for scientific simulations) is preferable when:

  • The low-fidelity and high-fidelity models have r² < 0.9 correlation — in this case, the multi-fidelity correction introduces noise rather than signal
  • The cheap model is only marginally faster (cost ratio < 10:1) — the overhead of multi-fidelity modeling may not justify the savings
  • You have sufficient budget for enough high-fidelity samples — if you can afford hundreds of expensive runs, single-fidelity approaches with adaptive sampling may be more practical
  • Your problem has only one fidelity level available — sometimes legacy simulations exist at only one accuracy level

Core Methods

The multi-fidelity surrogate modeling landscape spans several distinct methodological families. Each has different assumptions, strengths, and weaknesses.

1. Co-Kriging (Multi-Fidelity Gaussian Processes)

Co-kriging is the most established multi-fidelity method, rooted in the Kennedy and O’Hagan (2000) autoregressive formulation. The key idea is that the high-fidelity process is modeled as a linear scaling of the low-fidelity process plus a discrepancy term:

y_hf(x) = τ × y_lf(x) + δ(x) + ε

where τ scales the low-fidelity prediction, δ(x) is a Gaussian process discrepancy, and ε is noise. The autoregressive formulation builds the high-fidelity model sequentially from low-fidelity predictions rather than treating all fidelity levels as independent inputs.

The standard co-kriging formulation (AR1) assumes a linear relationship between fidelity levels. More flexible formulations include:

  • AR0: The high-fidelity process is independent of the low-fidelity process (τ = 0), modeling only the discrepancy term
  • AR1: The standard autoregressive formulation with linear scaling
  • Hierarchical kriging: Bypasses explicit cross-covariance matrix construction, matching co-kriging accuracy with simpler implementation

Toal (2015) showed that AR1 performs well when correlation exceeds r² > 0.9, while AR0 can be preferable when the correlation is lower but the models share some structural similarity.

Recent advances (2024-2026): MAGPI (Multifidelity-Augmented GP Inputs) uses low-fidelity predictions as additional spatial features to condition the high-fidelity input space, avoiding large multi-output matrix inversions while maintaining uncertainty quantification. Recursive EM co-kriging (2025) decouples optimization for noisy, non-nested data using closed-form updates, dramatically reducing offline training time.

2. Neural Operator Multi-Fidelity Architectures

Neural operators have emerged as a powerful multi-fidelity framework, particularly for PDE-constrained problems. The experimental comparison by Adam Faza et al. (2026) across four test cases identified several distinct architectures:

Transfer learning (best performing): Train a neural operator on low-fidelity data first, then fine-tune on high-fidelity data. The architecture learns the cheap simulation behavior before adapting to expensive ground truth. Across all test cases, only transfer learning consistently outperformed the high-fidelity-only baseline, contradicting the common intuition that joint training should work best. This is particularly valuable for unsteady flow problems where direct low-fidelity incorporation fails generalization.

Intermediate (joint training): Train a single neural operator on data from both fidelity levels simultaneously. This approach has the intuitive appeal of learning both models jointly but performs poorly when the low-fidelity to high-fidelity discrepancy is large. Conflicting information from the two fidelity levels confuses the network.

Residual learning: Train the network to predict the difference between high-fidelity and low-fidelity predictions rather than the high-fidelity output directly. This architecture can be useful when the residual is simpler than the full output but requires accurate low-fidelity predictions as input.

Two-step architecture: Train one network on low-fidelity data and a second network on the discrepancy, chaining the predictions. This decouples the learning tasks but introduces compounding errors.

Faza et al. found that multi-fidelity neural operators are more sensitive to low-fidelity to high-fidelity discrepancy than single-fidelity baselines. Direct low-fidelity incorporation strategies (intermediate, residual, two-step) degrade when the discrepancy grows large, while transfer learning remains stable across timestep variations.

The most relevant neural operator architectures for multi-fidelity include Fourier Neural Operators (FNO) and DeepONet variants. Tang et al. (2024) demonstrated Fourier neural operators for geological carbon storage applications, while Lu et al. (2022) introduced multi-fidelity DeepONet architectures.

Wu et al. (2022) proposed multi-fidelity Hierarchical Neural Processes (MF-HNP) as a unified neural latent variable model for scalable multi-fidelity surrogate modeling, offering an alternative to operator-based approaches.

3. Reduced-Order Surrogates

Reduced-order modeling (ROM) techniques such as Proper Orthogonal Decomposition (POD) combined with temporal methods like LSTM can build multi-fidelity surrogates for time-dependent systems. The ContiPaolo/MultiFidelity_POD repository provides an open-source implementation of POD-based multi-fidelity surrogate modeling with tutorial notebooks.

The approach works by extracting dominant modes from low-fidelity simulation data, then learning to correct those modes using high-fidelity data. This is particularly attractive for systems where the dominant physical behavior is qualitatively captured by the low-fidelity model, and the high-fidelity corrections are relatively small.

4. Hybrid ML Corrections

Hybrid approaches combine traditional surrogate modeling with machine learning correction networks. For example, a Gaussian process surrogate built on low-fidelity data can be corrected by a neural network trained on high-fidelity data. This approach leverages the strong uncertainty quantification of Gaussian processes while benefiting from the flexibility of neural networks to learn complex discrepancies.

Ravi et al. (2024) provided a comprehensive comparison of multi-fidelity Gaussian process surrogate modeling methods, including autoregressive formulations, hierarchical approaches, and latent-map multi-output Gaussian processes.

Practical Implementation

The Python ecosystem for multi-fidelity modeling is fragmented but maturing. Three major toolkits cover different aspects of the landscape. Understanding which tool fits your problem is essential.

SMT: Multi-Fidelity Gaussian Processes

SMT (Surrogate Modeling Toolbox) provides the most comprehensive multi-fidelity Kriging implementation in Python, including MFK (Multi-Fidelity Kriging) and MFCK (Multi-Fidelity Co-Kriging). It supports both autoregressive and latent-map formulations and integrates well with scipy-based workflows.

Image suggestion: A fidelity hierarchy diagram illustrating the data flow through SMT’s co-kriging pipeline: low-fidelity simulations → high-fidelity samples → correlation estimation → co-kriging model → corrected predictions.

Here is a practical example using SMT’s multi-fidelity co-kriging:

import numpy as np
from smt.smt import MultiFidelityKriging
from smt.surveys import design_of_experiments as doe

# Low-fidelity data (cheap simulations)
lf_x = doe.sobol(100, 2)  # 100 samples, 2 input dimensions
lf_y = np.sin(lf_x[:, 0]) + 0.1 * lf_x[:, 1]  # Simplified physics

# High-fidelity data (expensive simulations)
hf_x = doe.latin_hypercube(20, 2)  # 20 expensive samples
hf_y = np.sin(hf_x[:, 0]) + 0.1 * hf_x[:, 1] + 0.05 * np.sin(5 * hf_x[:, 0])  # Full physics

# Build multi-fidelity co-kriging model
model = MultiFidelityKriging()
model.lf_des = lf_x
model.lf_resp = lf_y
model.hf_des = hf_x
model.hf_resp = hf_y

# Train the model
model.execute()

# Predict for new design points
test_points = doe.latin_hypercube(50, 2)
predictions = model.hf_response(test_points)

The key insight from Toal (2015) applies here: verify that the correlation between lf_y and hf_y exceeds r² > 0.9 before relying on the multi-fidelity model. You can estimate this correlation empirically before training.

DeepXDE: Physics-Informed Multi-Fidelity Neural Operators

DeepXDE provides infrastructure for physics-informed neural operators with multi-fidelity capabilities. The framework combines physics constraints (PDE residuals) with multi-fidelity data, making it particularly useful when you have governing equations available at multiple fidelity levels.

For multi-fidelity neural operator training with DeepXDE:

import deepxde as dde
import numpy as np

# Define the physics problem (example: 1D Poisson equation)
def physics_function(x):
    # Ground truth: -u''(x) = f(x) with boundary conditions
    u_exact = np.sin(np.pi * x)
    f = np.pi**2 * u_exact
    return f

# Low-fidelity data
x_lf = np.linspace(0, 1, 50)[:, np.newaxis]
u_lf = np.sin(np.pi * x_lf) + 0.02 * np.random.rand(50, 1)

# High-fidelity data (expensive)
x_hf = np.linspace(0, 1, 20)[:, np.newaxis]
u_hf = np.sin(np.pi * x_hf)  # True solution

# Multi-fidelity neural operator setup
# Transfer learning: train on LF first, then fine-tune on HF
# This is the architecture that consistently outperforms others
# across PDE test cases (Faza et al., 2026)

The transfer learning approach here trains a neural operator on the low-fidelity data first (learning the general solution behavior), then fine-tunes on the high-fidelity data (adapting to the accurate ground truth). This weight-initialization approach is more robust than joint training when the fidelity gap is large.

DeepXDE is particularly useful when you have PDE residuals available and want to enforce physics constraints alongside multi-fidelity data. This is known as physics-informed multi-fidelity modeling.

MultiFidelity_POD: Reduced-Order Multi-Fidelity Modeling

The MultiFidelity_POD repository provides Reduced-order modeling using Proper Orthogonal Decomposition combined with temporal methods for time-dependent multi-fidelity systems. This is particularly useful for unsteady problems where you need both spatial and temporal fidelity correction.

# MultiFidelity_POD usage pattern
import MultiFidelity_POD as mfpod

# Load low-fidelity and high-fidelity simulation snapshots
lf_snapshots = np.load('lf_snapshots.npy')  # Shape: (time_steps, spatial_modes)
hf_snapshots = np.load('hf_snapshots.npy')  # Shape: (time_steps, spatial_modes)

# Build reduced-order multi-fidelity model
model = mfpod.MultiFidelityROM()
model.fit(lf_snapshots, hf_snapshots)

# Predict unsteady behavior at new conditions
predictions = model.predict_new_conditions(test_conditions)

MultiFidelity_POD is ideal when your problem involves time-dependent simulation data (unsteady CFD, transient thermal analysis) and you need to correct both spatial and temporal behavior. The repository includes tutorial notebooks demonstrating the workflow.

Choosing Your Toolkit

Requirement Best Tool Why
Gaussian process with UQ SMT Most comprehensive GP toolkit, mature co-kriging implementations
Physics-informed neural operators DeepXDE Built-in PDE constraints, transfer learning support
Reduced-order time-dependent MultiFidelity_POD POD-LSTM workflows, unsteady simulation data
Quick prototyping SMT Well-documented, scipy-compatible
Custom neural architectures DeepXDE TensorFlow/PyTorch flexibility, custom architectures
Legacy ROM workflows MultiFidelity_POD Integrates with existing POD pipelines

The ecosystem is maturing — benchmark suites like MF2 are beginning to provide standardized comparison frameworks. Until a unified toolkit emerges, practitioners should select tools based on their specific fidelity requirements, available data, and computational constraints.

Case Studies

Aerospace CFD: Transonic Airfoil Optimization

One of the most established multi-fidelity applications is aerodynamic shape optimization. Fernández-Godino et al. (2023) documented that fluid mechanics (46%) and solid mechanics (25%) dominate multi-fidelity applications in the surveyed literature.

The typical workflow for airfoil optimization uses:

  • Low-fidelity: Potential-flow solver (seconds per run)
  • High-fidelity: Full Navier-Stokes solver with turbulence modeling (minutes to hours per run)

The potential-flow model captures the dominant pressure distribution characteristics accurately but misses viscous effects and shock-wave physics. The multi-fidelity surrogate learns the discrepancy, enabling rapid evaluation of thousands of design candidates using mostly cheap potential-flow simulations with select Navier-Stokes validation runs.

Multi-fidelity Bayesian optimization using this approach has been demonstrated to reduce the number of high-fidelity evaluations required for airfoil optimization by orders of magnitude compared to single-fidelity approaches. The correlation between potential-flow and Navier-Stokes predictions is typically high enough (r² > 0.9) to satisfy Toal’s conditions, making this a strong candidate for multi-fidelity modeling.

Robert Wenink’s practical explanation provides an excellent pedagogical walkthrough of this workflow using the Forrester et al. benchmark problem, demonstrating how co-kriging leverages the cheap-to-expensive data ratio effectively.

Composite Mechanics: Multi-Fidelity Surrogates for Composites

Wen (2026) demonstrated multi-fidelity surrogate modeling for composite mechanics, transitioning from co-kriging to multi-fidelity neural networks. The study addressed the prediction of mechanical properties for composite laminates under various loading conditions, where:

  • Low-fidelity: Layer-wise theory model (fast, captures macroscopic behavior)
  • High-fidelity: Full 3D finite element analysis at the ply level (accurate, computationally expensive)

The study showed that co-kriging outperformed single-fidelity Gaussian processes when the correlation between layer-wise theory and full 3D FEM exceeded r² > 0.9. For cases where the correlation was moderate, the study transitioned to multi-fidelity neural networks, which handle larger discrepancies more robustly.

This case highlights a practical decision: when low-fidelity to high-fidelity correlation is strong, co-kriging is efficient and well-understood. When the correlation is weaker (as can occur with complex loading scenarios or off-axis plies), neural operator approaches may be preferable.

Geological Carbon Storage: Multi-Fidelity Flow Simulation

Predicting CO₂ plume migration over decades requires solving multiphase flow equations with full thermodynamic coupling. Fine-grid simulations with full physics are prohibitively expensive for uncertainty quantification, which requires thousands of realizations.

Multi-fidelity approaches combine:

  • Low-fidelity: Coarse-grid simulations with simplified thermodynamics (cheap)
  • High-fidelity: Fine-grid simulations with full thermodynamic coupling (expensive)

Tang et al. (2024) demonstrated Fourier Neural Operators for geological carbon storage applications, showing that multi-fidelity neural operators can learn the discrepancy between coarse and fine grid simulations while respecting the underlying physics constraints.

This application is particularly interesting because the fidelity gap involves both grid resolution AND physical model simplification. The low-fidelity model uses coarser grids and simplified thermodynamics, while the high-fidelity model resolves fine-scale heterogeneity and full phase behavior. This is closer to the “governing-equation differences” scenario (RANS vs. LES in CFD) than simple grid coarsening, making it a challenging but practically important test case.

Trade-offs and Decision Framework

Multi-fidelity surrogate modeling offers significant potential for reducing computational cost, but it introduces complexity that must be carefully managed.

Complexity vs. Accuracy

The primary trade-off in multi-fidelity modeling is between model complexity and accuracy gain. Multi-fidelity approaches require:

  • More data collection: You need data from multiple fidelity levels, not just one
  • Correlation estimation: You must estimate the correlation between fidelity levels
  • More sophisticated algorithms: Co-kriging, neural operators, and reduced-order methods are more complex than single-fidelity Kriging or basic neural networks
  • Parameter tuning: Multi-fidelity models have additional hyperparameters (correlation ratios, fidelity weights)

The accuracy gain must justify this complexity. For problems requiring thousands of simulations where high-fidelity runs take hours, multi-fidelity modeling can reduce total computation time by orders of magnitude. For problems with modest simulation counts, the overhead may not be worthwhile.

Decision Framework

Use this decision framework to determine when multi-fidelity modeling is appropriate:

When to use multi-fidelity:

  • High-fidelity simulations are expensive (hours per run) and you need many evaluations (hundreds+)
  • Low-fidelity simulations are available and correlated (r² > 0.9) with high-fidelity results
  • You have historical low-fidelity data that you can leverage
  • Your accuracy requirements are moderate for exploration phases

When to use single-fidelity:

  • High-fidelity simulations are cheap enough (minutes per run) that you can afford enough samples
  • Low-fidelity models have weak correlation (r² < 0.9) with high-fidelity results
  • You only have one fidelity level available
  • You need final validation accuracy and cannot rely on cheap model corrections

When MF complexity may not be worth it:

  • The fidelity gap is small (cost ratio < 10:1) — the overhead may not justify savings
  • Your problem has weak correlation between fidelity levels — the multi-fidelity correction introduces noise
  • You have sufficient budget for adaptive single-fidelity sampling — single-fidelity adaptive sampling can be more effective

Practical Recommendations

  1. Estimate correlation first: Before investing in multi-fidelity modeling, estimate the correlation between available low-fidelity and high-fidelity data. If r² < 0.9, reconsider whether multi-fidelity is appropriate or whether you need a different low-fidelity model.
  2. Start with co-kriging: If correlation is strong, start with co-kriging (SMT). It is well-understood, provides reliable uncertainty quantification, and is easier to implement than neural operator approaches.
  3. Consider transfer learning for neural operators: If you need neural operator flexibility (high-dimensional inputs, complex geometries), transfer learning consistently outperforms other architectures across test cases (Faza et al., 2026).
  4. Monitor the discrepancy: Track how the low-fidelity to high-fidelity discrepancy evolves during training. If it grows too large, the multi-fidelity model may degrade — this is when single-fidelity approaches or different low-fidelity models may be preferable.
  5. Validate with holdout data: Always validate multi-fidelity predictions against holdout high-fidelity data. Multi-fidelity models can overfit to the discrepancy structure, especially when correlation is moderate.

Summary

Multi-fidelity surrogate modeling combines cheap low-fidelity simulations with expensive high-fidelity data to achieve accurate predictions at significantly lower computational cost. The framework exploits the correlation between fidelity levels, using machine learning to learn and correct the discrepancy between them.

Key practical insights:

  • Transfer learning is currently the most robust multi-fidelity neural operator strategy across PDE test cases, consistently outperforming joint training architectures
  • Multi-fidelity Kriging has narrow applicability conditions (r² > 0.9 correlation, budget fraction 0.1-0.8) that are often overlooked
  • The Python ecosystem is fragmented — SMT, DeepXDE, and MultiFidelity_POD each cover different aspects, and no single library does everything
  • The hardest practical problems involve governing-equation differences (RANS vs. LES) rather than simple grid coarsening
  • Single-fidelity surrogate modeling may be sufficient when correlation is weak or computational budget is adequate

For practitioners considering multi-fidelity modeling, the decision framework above provides concrete guidance on when to use it and when to avoid it. The core message is clear: multi-fidelity surrogates are powerful when the conditions are met, but they add complexity that must be justified by the accuracy gain and computational savings.

If you are exploring surrogate modeling approaches more broadly, our guide to machine learning surrogates for scientific simulations covers the single-fidelity foundations, while our polynomial chaos expansions guide provides an alternative fast surrogate approach.

Related guides

Key References

Next Steps

If you are evaluating multi-fidelity approaches for your specific problem:

  1. Assess the correlation between available low-fidelity and high-fidelity models (estimate r² empirically)
  2. Estimate the cost ratio and total simulation budget
  3. Check Toal’s conditions (correlation > 0.9, budget fraction 0.1-0.8)
  4. If conditions are met, prototype with SMT’s co-kriging for Gaussian process approaches or DeepXDE’s transfer learning for neural operators
  5. Validate against holdout high-fidelity data before deploying

For practitioners working with time-dependent systems, the MultiFidelity_POD repository provides tutorial notebooks demonstrating reduced-order multi-fidelity workflows. For those exploring multi-fidelity Bayesian optimization, follow-up work on MF-EGO and adaptive sampling strategies builds on the foundations described here.