2919 Surrogate Guidelines 146893b4

Surrogate Model Guidelines

Overview

Surrogate models (metamodels, emulators) approximate expensive simulations with fast-to-evaluate functions. They enable rapid optimization, sensitivity analysis, and uncertainty quantification.

Model Comparison

Polynomial Response Surface

How It Works

Fit polynomial of specified order to simulation data:

y = b0 + sum(b_i * x_i) + sum(b_ij * x_i * x_j) + ...

Orders:

• Linear: 1 + d terms
• Quadratic: 1 + d + d*(d+1)/2 terms

When to Use

• Very limited data (< 20 points)
• Smooth, nearly quadratic response
• Need interpretable coefficients
• Quick approximation

When to Avoid

• Highly nonlinear responses
• Extrapolation required
• High dimensions (coefficient explosion)

Sample Requirements

Radial Basis Functions (RBF)

How It Works

Interpolate using weighted sum of radial basis functions centered at data points:

y(x) = sum(w_i * phi(||x - x_i||))

Common kernels:

• Gaussian: exp(-r^2 / epsilon^2)
• Multiquadric: sqrt(1 + (epsilon*r)^2)
• Thin-plate spline: r^2 * log(r)

When to Use

• Exact interpolation required
• Moderate dimensions (< 20)
• No noise in data
• Complex response surfaces

When to Avoid

• Noisy data (will fit noise)
• Very large datasets (O(n^3) fitting)
• Need uncertainty estimates

Key Hyperparameters

Gaussian Process (Kriging)

How It Works

Model output as realization of Gaussian Process with specified mean and covariance (kernel):

y(x) ~ GP(m(x), k(x, x'))

Provides:

• Mean prediction: E[y(x)]
• Uncertainty: Var[y(x)]

When to Use

• Need uncertainty quantification
• Expensive simulations (BO framework)
• Smooth responses
• Sequential/adaptive sampling

When to Avoid

• Very large datasets (> 1000 points)
• High dimensions (> 15-20)
• Very fast simulations

Kernel Selection

Libraries

• GPyTorch (PyTorch, scalable)
• GPy (numpy, flexible)
• scikit-learn (simple API)

Neural Networks

When to Use

• Very large datasets (> 10000 points)
• High dimensions
• Complex nonlinear patterns
• Have GPU resources

When to Avoid

• Small datasets (< 100 points)
• Need uncertainty (without extra work)
• Interpretability required
• Training time is limited

Validation Strategies

Cross-Validation

Metrics

Red Flags

Adaptive Sampling

When initial surrogate is poor, add samples strategically:

Decision Flowchart

START
  |
  v
Is data noisy?
  |
  +-- YES --> Need uncertainty?
  |             |
  |             +-- YES --> GAUSSIAN PROCESS
  |             |
  |             +-- NO --> NEURAL NETWORK (if large data)
  |
  +-- NO --> Is response smooth and low-dim?
               |
               +-- YES --> Is data < 20 points?
               |             |
               |             +-- YES --> POLYNOMIAL
               |             |
               |             +-- NO --> RBF or GP
               |
               +-- NO --> RBF or GP with Matern kernel

Implementation Notes

The surrogate_builder.py script in this skill:

• Is a placeholder for demonstration
• Computes basic MSE metric only
• Does not fit actual models

For real surrogate modeling, use:

• scikit-learn (polynomial, GP, neural networks)
• scipy.interpolate (RBF)
• GPyTorch (scalable GPs)
• SMT (Surrogate Modeling Toolbox)