如何在Python中实现N维非线性多项式/样条回归（适配Sobol分析）

Absolutely! The Python ecosystem has great tools for N-dimensional nonlinear polynomial and spline regression—including support for Catmull-Rom splines—perfect for fitting the surrogate models you need before running Sobol sensitivity analysis. Let’s break down your options:

For polynomial-based surrogate models, you can combine feature engineering with regression models to capture nonlinear relationships across your N attributes:

• scikit-learn Pipeline: Use PolynomialFeatures to generate high-dimensional polynomial terms (like cross-products and powers) paired with a regression model (e.g., LinearRegression, KernelRidge for more flexibility). This is straightforward and integrates well with standard ML workflows.

Here’s a quick example for N=3 features:

import numpy as np
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import make_pipeline

# Sample N-dimensional data
X = np.random.rand(100, 3)  # 100 samples, 3 attributes
y = np.sin(X[:,0]) + X[:,1]**2 + np.exp(-X[:,2])  # Nonlinear target

# Build polynomial regression pipeline (degree 3 captures nonlinearity)
poly_surrogate = make_pipeline(PolynomialFeatures(degree=3), LinearRegression())
poly_surrogate.fit(X, y)

# Predict on new input
new_params = np.random.rand(1, 3)
prediction = poly_surrogate.predict(new_params)

Catmull-Rom splines are a type of cubic spline that’s smooth and preserves data points—ideal for fitting continuous, nonlinear N-dimensional data. Here’s how to implement them:

1. Regular Grid Data (Catmull-Rom via scipy) #

If your measurements are on a regular N-dimensional grid, scipy.interpolate.RegularGridInterpolator supports Catmull-Rom splines via the method='cubic' parameter (scipy’s cubic interpolation for regular grids uses Catmull-Rom under the hood):

from scipy.interpolate import RegularGridInterpolator

# Create a 3D regular grid example
x = np.linspace(0, 1, 20)
y = np.linspace(0, 1, 20)
z = np.linspace(0, 1, 20)
X_grid, Y_grid, Z_grid = np.meshgrid(x, y, z, indexing='ij')

# Generate synthetic target data on the grid
target = np.sin(X_grid) + Y_grid**2 + np.exp(-Z_grid)

# Initialize Catmull-Rom spline interpolator
catmull_rom_interp = RegularGridInterpolator((x, y, z), target, method='cubic')

# Predict on a single N-dimensional point
new_point = np.array([0.5, 0.3, 0.7])
prediction = catmull_rom_interp(new_point)

2. Irregularly Sampled Data #

If your data points aren’t on a regular grid, use radial basis function (RBF) interpolation (which acts like a spline surrogate) or custom Catmull-Rom implementations:

from scipy.interpolate import Rbf

# Irregular 3D sample data
X_irregular = np.random.rand(100, 3)
y_irregular = np.sin(X_irregular[:,0]) + X_irregular[:,1]**2 + np.exp(-X_irregular[:,2])

# RBF interpolator with cubic kernel (spline-like behavior)
rbf_surrogate = Rbf(X_irregular[:,0], X_irregular[:,1], X_irregular[:,2], y_irregular, function='cubic')

# Predict on new point
prediction = rbf_surrogate(0.5, 0.3, 0.7)

To use your fitted model for Sobol analysis:

• Wrap the model as a callable function: Sobol libraries (like SALib) require a function that takes a 1D array of N parameters and returns a single prediction. For example:

  def surrogate_model(params):
      # Reshape 1D input to match model expectations
      return poly_surrogate.predict(params.reshape(1, -1))[0]
  

• Avoid overfitting: Use cross-validation (e.g., sklearn.model_selection.cross_val_score) to tune model complexity (like polynomial degree or spline smoothness) — overfit models will produce misleading sensitivity results.

内容的提问来源于stack exchange，提问作者lelorrain7