---
title: 'SMT 2.0: Surrogate Modeling Toolbox'
url: https://www.emergentmind.com/topics/surrogate-modeling-toolbox-smt-2-0
type: topic
---

# SMT 2.0: Surrogate Modeling Toolbox

Searching arXiv for SMT 2.0 and closely related SMT papers to ground the article in cited sources.
arXiv search query: SMT 2.0 Surrogate Modeling Toolbox hierarchical mixed variables Gaussian processes
The **Surrogate Modeling Toolbox (SMT 2.0)** is an open-source Python package for surrogate modeling of expensive simulations that combines **surrogate models**, **sampling methods**, **benchmark/sample problems**, and **applications** such as Bayesian optimization [2305.13998]. In its 2023 major release, SMT 2.0 extends earlier SMT functionality beyond continuous-variable settings toward **mixed-variable** and **hierarchical or conditionally active** design spaces, while also broadening support for sampling, noisy and multifidelity data, new surrogate models, and derivative-related computations for Kriging [2305.13998]. The release is presented as, to the authors’ knowledge, the **first open-source surrogate-modeling library** that natively supports **both mixed-variable and hierarchical-input Gaussian process/Kriging models** in a unified Python toolbox [2305.13998].

## 1. Historical position and scope

SMT 2.0 emerged from a broader SMT framework already oriented toward derivative-aware surrogate modeling, including Kriging/Gaussian processes with gradient information, KPLS/GEKPLS, and spline-based models [2305.13998]. The new release preserves that orientation while broadening the toolbox toward real engineering settings in which the design space is not a purely continuous Euclidean box [2305.13998].

The paper presents SMT 2.0 simultaneously as a scientific contribution and a software release. At the software level, the repository is organized into submodules such as `sampling_methods`, `problems`, and `surrogate_models`, and the release also highlights **applications** and **interactive notebooks** [2305.13998]. At the methodological level, the release introduces native handling of **mixed discrete/continuous variables** and **hierarchical or conditionally active variables**, adds new surrogate families such as **GENN** and **MGP**, extends sampling methods, supports noisy and multifidelity data, and computes **variance and kernel derivatives for Kriging** [2305.13998].

Intended use cases include **design space exploration, uncertainty quantification, surrogate-assisted optimization, Bayesian optimization/EGO, multifidelity modeling, and data fusion**, especially for computationally expensive engineering simulations [2305.13998]. Canonical engineering problems available in the package include wing weight, robot arm, borehole, and beam problems, alongside new examples specifically designed to exercise mixed and hierarchical variables [2305.13998].

A central conceptual distinction, made clearer by comparison with optimization-oriented frameworks such as MATSuMoTo, is that SMT 2.0 is fundamentally **modeling-first** rather than **optimization-first**. MATSuMoTo is described as a full surrogate-based optimization framework for expensive black-box global optimization, whereas SMT 2.0 is primarily a toolbox for constructing and using surrogate models, often to be embedded within larger optimization workflows [1404.4261]. This suggests that SMT 2.0’s identity lies in flexible metamodel construction and design-space handling rather than in prescribing a single end-to-end optimization loop.

## 2. Core problem classes: mixed, hierarchical, and structured inputs

The main motivation for SMT 2.0 is that modern engineering design problems often involve **continuous variables**, **ordered or integer variables**, **categorical variables**, and **hierarchical or conditional variables** that are active only under certain architectural choices [2305.13998]. Examples given in the paper include aircraft propulsion architectures, structural sections or materials, neural-network hyperparameter tuning, multidisciplinary architecture optimization, chemical process design, and mixed-integer nonlinear black-box optimization more broadly [2305.13998].

SMT 2.0 supports design spaces containing **continuous, integer/ordinal, and categorical variables** [2305.13998]. Ordinal and integer variables are handled similarly to continuous variables through ordered relaxation, while categorical variables are treated with specialized kernels [2305.13998]. A further step, developed in later work, is the representation of **mixed-variable, hierarchical, conditional, heterogeneous, tree-structured, and graph-structured design spaces** using a unified framework implemented in SMT 2.0 [2506.22621].

Within that unified framework, a point is written as
\[
\mathbf{X} = (X_1,\ldots,X_n),
\]
and variables may have four data types: **continuous**, **integer**, **ordinal**, and **categorical** [2506.22621]. Variables are also assigned structural roles derived from a graph of dependencies: **meta**, **meta-decreed**, **decreed**, and **neutral** [2506.22621]. A **meta variable** governs the existence or support of other variables; a **decreed variable** depends on a parent variable for inclusion or exclusion; and the framework further introduces **partially-decreed variables**, which remain present but with support restricted by parent context [2506.22621].

That later extension formalizes support restriction using sets. For variable \(x_i\) with full value space \(\mathcal{X}_i\) and parent set \(P_i\),
\[
\mathcal{S}_{\mathcal{G}}(x_i \mid P_i) \subseteq \mathcal{X}_i
\]
is the admissible support under the graph \(\mathcal{G}\), and the variable is excluded iff
\[
\mathcal{S}_{\mathcal{G}}(x_i \mid P_i) = \emptyset.
\]
A variable is **partially decreed** by parent \(x_j\) when
\[
\mathcal{S}_{\mathcal{G}}(x_i \mid x_j) \subset \mathcal{X}_i
\quad \text{and} \quad
\mathcal{S}_{\mathcal{G}}(x_i \mid x_j) \neq \emptyset
\]
[2506.22621]. This generalizes the simpler on/off inclusion logic emphasized in the 2023 SMT 2.0 paper.

The same 2025 framework introduces **Design Space Graphs** and **Architecture Design Space Graphs** as graph-based encodings of such relationships, extending hierarchical design-space handling from simple trees toward DAG-based structures with mixed node and relation types [2506.22621]. A cautious implication is that SMT 2.0 evolved from supporting hierarchical variables in Kriging models to supporting graph-aware design-space semantics more generally.

## 3. Gaussian-process and Kriging methodology

SMT 2.0’s flagship methodological contribution is the extension of Gaussian process/Kriging models to **mixed-variable** and **hierarchical** inputs [2305.13998]. The release paper assumes the standard Kriging framework, with predictive mean and variance of the form
\[
\mu(x) = f(x)^\top \hat{\beta} + r(x)^\top R^{-1}(y - F\hat{\beta}),
\]
\[
\sigma^2(x) = \hat{\sigma}^2 \left[ 1 - r(x)^\top R^{-1} r(x) + \left(f(x)-F^\top R^{-1}r(x)\right)^\top (F^\top R^{-1}F)^{-1} \left(f(x)-F^\top R^{-1}r(x)\right) \right]
\]
[2305.13998]. Hyperparameters are optimized through GP log-likelihood, and SMT 2.0 extends the implementation to support kernel derivatives, variance prediction, and variance derivatives for Kriging [2305.13998].

For mixed variables, SMT 2.0 treats quantitative and categorical parts separately and combines them multiplicatively [2305.13998]. For quantitative variables, the paper writes
\[
k^{qnt}(u^{qnt}, v^{qnt}) = \prod_{i=1}^{n} \exp\!\left(-d(u_i^{qnt},v_i^{qnt})\right).
\]
For categorical variables, a unified construction is given as
\[
k^{cat}(c^r,c^s,\theta^{cat}) = \prod_{i=1}^{l} \kappa\!\left( 2 [\Phi(\Theta_i)]_{\ell_i^s,\ell_i^r} \right) \, \kappa\!\left( [\Phi(\Theta_i)]_{\ell_i^r,\ell_i^r} \right) \, \kappa\!\left( [\Phi(\Theta_i)]_{\ell_i^s,\ell_i^s} \right),
\]
where \(\Phi(\Theta_i)\) is a symmetric positive definite matrix-valued mapping and \(\kappa\) depends on the categorical model [2305.13998].

SMT 2.0 implements four categorical kernels:

| Kernel | SMT name in paper | Hyperparameter structure |
|---|---|---|
| Gower-distance-based kernel | `GOWER_KERNEL` | 1 hyperparameter per categorical variable |
| Continuous relaxation kernel | `CONT_RELAX_KERNEL` | \(L_i\) hyperparameters for variable \(i\) |
| Homoscedastic hypersphere kernel | `HOMO_HSPHERE_KERNEL` | \(\frac{1}{2}L_i(L_i-1)\) hyperparameters |
| Exponential homoscedastic hypersphere kernel | `EXP_HOMO_HSPHERE_KERNEL` | \(\frac{1}{2}L_i(L_i-1)\) hyperparameters |

The paper gives the following specific parameterizations [2305.13998]. For **SMT GD**,
\[
\kappa(\phi) = \exp(-\phi),
\]
\[
[\Phi(\Theta_i)]_{j,j} = \frac{1}{2}\theta_i, \qquad [\Phi(\Theta_i)]_{j\neq j'} = 0.
\]
For **SMT CR**,
\[
\kappa(\phi) = \exp(-\phi),
\]
\[
[\Phi(\Theta_i)]_{j,j} = [\Theta_i]_{j,j}, \qquad [\Phi(\Theta_i)]_{j\neq j'} = 0.
\]
For **SMT EHH**,
\[
\kappa(\phi) = \exp(-\phi),
\]
\[
[\Phi(\Theta_i)]_{j,j} = 0, \qquad [\Phi(\Theta_i)]_{j\neq j'} = \frac{\log \epsilon}{2} \left( [C(\Theta_i)C(\Theta_i)^\top]_{j,j'} - 1 \right).
\]
For **SMT HH**,
\[
\kappa(\phi) = \phi,
\]
\[
[\Phi(\Theta_i)]_{j,j} = 1, \qquad [\Phi(\Theta_i)]_{j\neq j'} = \frac{1}{2}[C(\Theta_i)C(\Theta_i)^\top]_{j,j'}.
\]
Here \(C(\Theta_i)\) is built by a hypersphere decomposition, ensuring positive definiteness of the categorical correlation matrix [2305.13998].

For hierarchical spaces, SMT 2.0 adopts a decomposition into **neutral variables** \(x_{neu}\), **meta variables** \(x_{met}\), and **decreed variables** \(x_{dec}\), with
\[
\mathcal{X} = (\mathcal{X}_{neu}, \mathcal{X}_{met}, \mathcal{X}_{dec}), \qquad
\mathcal{X}_{dec} = \bigcup_{x_{met}\in\mathcal{X}_{met}} \mathcal{X}_{inc}(x_{met})
\]
[2305.13998]. The hierarchical kernel takes the form
\[
k(u,v) = k_{neu}(u_{neu},v_{neu}) \; k_{met}(u_{met},v_{met}) \; k_{met,dec}\!\left([u_{met},u_{inc}(u_{met})],[v_{met},v_{inc}(v_{met})]\right).
\]

SMT 2.0 provides two dedicated hierarchical kernels: the **SMT Arc-Kernel** and the **SMT Alg-Kernel** [2305.13998]. The **Alg-Kernel**, introduced as novel in the paper, factorizes the meta-decreed component as
\[
k^{alg}_{met,dec} \!\left([u_{met},u_{inc}(u_{met})],[v_{met},v_{inc}(v_{met})]\right)
=
k^{alg}_{met}(u_{met},v_{met}) \; k^{alg}_{dec}(u_{inc}(u_{met}),v_{inc}(v_{met})).
\]
If decreed variable \(i\) is active in both points,
\[
d^{alg}\!\left([u_{inc}(u_{met})]_i,[v_{inc}(v_{met})]_i\right)
=
\left(
\frac{ 2\left|[u_{inc}(u_{met})]_i - [v_{inc}(v_{met})]_i\right| }
{ \sqrt{([u_{inc}(u_{met})]_i)^2+1}\; \sqrt{([v_{inc}(v_{met})]_i)^2+1} }
\right)\theta_i,
\]
while if it is not jointly active,
\[
d^{alg}\!\left([u_{inc}(u_{met})]_i,[v_{inc}(v_{met})]_i\right) = 1.0\,\theta_i
\]
[2305.13998]. The release paper argues that this gives Arc-like behavior without extra hyperparameters and with improved numerical stability [2305.13998].

The later unified-framework paper places these kernels within a broader theory of hierarchical distances and graph-structured kernels. It defines variable-wise distances
\[
d_i(X_i,X_i')=
\begin{cases}
d(X_i,X_i'), & \text{if } X_i,X_i' \in \mathcal{S}_i, \\
\delta_i, & \text{if exactly one of } X_i, X_i' = \emptyset, \\
0, & \text{if } X_i = X_i' = \emptyset,
\end{cases}
\]
with
\[
\delta_i = \max\{d(X_i,X_i') : X_i,X_i' \in \mathcal{S}_i\}/2,
\]
and the aggregate distance
\[
dist_p(\mathbf{X},\mathbf{X}') := \left( \sum_{i=1}^{n} d_i(X_i,X_i')^p \right)^{1/p}
\]
[2506.22621]. This later development suggests a generalization from hierarchical kernels on fixed conditional spaces toward kernels defined over graph-constrained structured domains.

## 4. Design-space abstraction, software architecture, and extensibility

A major API addition in SMT 2.0 is the `DesignSpace` class, through which users define variables with explicit types such as `FloatVariable`, `OrdinalVariable`, `CategoricalVariable`, and `IntegerVariable` [2305.13998]. Conditional activity is declared through `declare_decreed_var`, allowing a variable to be active only when a meta variable takes designated values [2305.13998].

The typical mixed or hierarchical GP workflow described in the paper is: define a `DesignSpace`, declare conditional activity, generate a valid design of experiments, evaluate the expensive function, instantiate a surrogate such as `KRG`, optionally wrap it with `MixedIntegerKrigingModel`, call `set_training_values`, train the model, and then use `predict_values` and `predict_variances` [2305.13998]. The example in the paper combines `MixedIntegerSamplingMethod`, `MixedIntegerKrigingModel`, and `KRG(design_space=..., corr="abs_exp", categorical_kernel=..., hierarchical_kernel=...)` [2305.13998].

The design-space layer also performs **correction** and **imputation**. Correction forces values into valid domains, such as rounding integers, while imputation replaces inactive variables with default values—\(0\) for discrete variables and midpoint of bounds for continuous variables [2305.13998]. The paper treats such imputation as a baseline rather than as the preferred modeling strategy for hierarchical inputs [2305.13998].

Later SMT 2.0 work extends the design-space abstraction through integration with **ConfigSpace** and **adsg-core**, introducing implementation classes `ConfigSpaceDesignSpaceImpl` and `AdsgDesignSpaceImpl` [2506.22621]. The newer `AdsgDesignSpaceImpl` supports mixed hierarchical variables, nested hierarchy, incompatibility and exclusion constraints, explicit graph structure, and explicit graph visualization [2506.22621]. The 2025 paper reports that, compared with `ConfigSpaceDesignSpaceImpl`, `AdsgDesignSpaceImpl` achieves **76% speedup** for correcting 1000 invalid points and computing activeness, **36% speedup** for generating one point by each discrete possibility, and **15% speedup** for generating 100 valid points [2506.22621].

SMT 2.0 is open source, distributed under the **New BSD license**, documented publicly, and designed to be extensible through abstract APIs for `SurrogateModel`, `SamplingMethod`, and `Problem` [2305.13998]. The project includes user and developer documentation, automated regression testing, notebooks reproducing paper results, and API conventions for adding new surrogates, samplers, and problems [2305.13998]. The package also uses **Numba** to accelerate some code paths; for a mixed Kriging model with 150 training points, the paper reports up to **80% speedup** in training time, with about 24 seconds of one-time JIT compilation overhead per install or upgrade [2305.13998].

A separate 2025 SMT paper extends extensibility specifically at the GP kernel layer, introducing a **base kernel class**, refactoring standard kernels into class-based structures, and enabling kernel composition with Python operators such as `+` and `*` [2507.09694]. That paper adds a **rational quadratic kernel** and a **periodic kernel**, intended for “frequency-aware” behavior in forecasting and oscillatory systems, and integrates them into SMT 2.0’s open-source framework [2507.09694]. This suggests that SMT 2.0’s architectural trajectory is toward increasingly modular and user-extensible kernel engineering.

## 5. Sampling, additional surrogate families, and data regimes

SMT 2.0 retains classic sampling families—**Random**, **Full Factorial**, and **LHS**—while extending them for mixed and hierarchical spaces [2305.13998]. The toolbox supports five LHS criteria: `center`, `maximin`, `centermaximin`, `correlation`, and `ese` [2305.13998]. Two additions are particularly emphasized. **NestedLHS** is introduced for multifidelity sampling, where low- and high-fidelity datasets should be nested, and **expand_lhs** enlarges an existing LHS while preserving the `ese` criterion [2305.13998]. The samplers were adapted to generate valid points in mixed and hierarchical spaces using `DesignSpace` rules [2305.13998].

Beyond classical Kriging variants, SMT 2.0 adds **GENN** and **MGP** [2305.13998]. **GENN** is a Gradient-Enhanced Neural Network: a fully connected multilayer perceptron trained on both function values and partial derivatives, with a loss incorporating response and gradient error [2305.13998]. **MGP**, or Marginal Gaussian Process, targets high-dimensional problems by assuming the function depends on a low-dimensional linear embedding. If
\[
\mathcal{A} = \{u = Ax,\; x\in\Omega\}, \qquad A\in\mathbb{R}^{d\times d_e}, \qquad d_e \ll d,
\]
and \(f(x) = f_{\mathcal{A}}(Ax)\), then one uses a kernel
\[
k(x,x') = k_{\mathcal{A}}(Ax, Ax')
\]
[2305.13998].

For high-dimensional problems, SMT 2.0 continues and extends **KPLS** and **KPLSK**, reducing the effective number of correlation hyperparameters from \(d\) to \(d_e\) and adding multifidelity versions **MFKPLS** and **MFKPLSK**, together with an automatic reduced-dimension criterion based on **Wold’s \(R\)** criterion [2305.13998]. The release also supports **noisy Kriging** and **heteroscedastic noise** via the `use_het_noise` option, and expands multifidelity modeling through **Variable-Fidelity Modeling (VFM)**, **Multi-Fidelity Kriging (MFK)**, **MFKPLS**, and **MFKPLSK** [2305.13998].

Subsequent papers reinforce several of these directions. A 2017 study on large-scale variable-fidelity surrogate modeling addresses the familiar GP bottleneck that exact inference becomes prohibitive when low-fidelity datasets reach thousands of points, and proposes Nyström-based sparse variable-fidelity GP and a prediction-time black-box low-fidelity update [1707.03916]. Although that work is not itself an SMT 2.0 paper, it is directly relevant to SMT’s multi-fidelity GP use cases, and a plausible implication is that it outlines one path for extending SMT’s multi-fidelity backend toward larger low-fidelity datasets.

The 2025 frequency-aware kernel paper further expands SMT 2.0’s GP regime by emphasizing user-defined kernels, compositional kernels, and periodic or multi-scale covariance structures for forecasting, oscillatory mechanics, and cyclic dynamics [2507.09694]. It introduces the rational quadratic kernel
\[
K^{\theta_l,\theta_k}(x, x') = \left( 1 + \frac{(x - x')^2}{\theta_l} \right)^{-\theta_k}
\]
and the periodic kernel
\[
K^{\theta_l,\theta_k}(x, x') = \exp\left(-\frac{\sin^2((x_l-x_l')\theta_l)}{\theta_k}\right)
\]
[2507.09694]. Composite kernels such as
\[
K(x,x') = K_{SE}^{\theta_1}(x, x') \cdot K_{Periodic}^{\theta_2, \theta_3}(x, x')
\]
and
\[
\begin{aligned}
K(x,x') = &\ K_{SE}^{\theta_1}(x, x') \cdot K_{Periodic}^{\theta_2, \theta_3}(x, x') \\
&+ K_{SE}^{\theta_4}(x, x') + K_{rational\_quadratic}^{\theta_5, \theta_6}(x, x')
\end{aligned}
\]
are used to model oscillatory signals and trend-plus-seasonality structures [2507.09694].

## 6. Empirical results, applications, and explainability

The 2023 SMT 2.0 paper evaluates mixed and hierarchical GP capabilities on both surrogate-modeling and Bayesian-optimization tasks [2305.13998]. In a mixed cantilever beam benchmark with continuous variables and one categorical cross-section variable, the paper compares four categorical kernels. With a 98-point LHS training set and \(10800\) validation points, the reported displacement RMSE and likelihood values are:

- **SMT GD**: RMSE \(1.3861\), likelihood \(111.13\), 3 hyperparameters
- **SMT CR**: RMSE \(1.1671\), likelihood \(155.32\), 14 hyperparameters
- **SMT EHH**: RMSE \(0.1613\), likelihood \(236.25\), 68 hyperparameters
- **SMT HH**: RMSE \(0.2033\), likelihood \(235.66\), 68 hyperparameters

[2305.13998]. The paper concludes that HH and EHH are markedly more accurate, but much more expensive to train, and recommends **CR by default** as the trade-off between model complexity and performance [2305.13998].

In a hierarchical neural-network benchmark, the number of hidden layers acts as a meta variable and neuron counts in later layers are decreed variables [2305.13998]. With a 99-point LHS training set and a 3000-point validation set, the reported results are:

- **SMT Alg-Kernel**: RMSE \(3.7610\), likelihood \(176.11\), 10 hyperparameters
- **SMT Arc-Kernel**: RMSE \(4.9208\), likelihood \(162.01\), 10 hyperparameters
- **Imp-Kernel**: RMSE \(4.5455\), likelihood \(170.64\), 10 hyperparameters

[2305.13998]. This benchmark is used to argue that the new **Alg-Kernel** outperforms the simplified Arc implementation and pure imputation in that setting [2305.13998].

The Bayesian-optimization examples further emphasize that kernel fidelity affects not only static prediction but also optimization performance [2305.13998]. In a mixed-variable toy function from CAT-EGO, EGO with HH and EHH converges in about 18 evaluations, whereas CR and GD take around 26 [2305.13998]. In a hierarchical modified Goldstein problem with 11 variables, both hierarchical kernels outperform imputation and random search, and one run of the Alg-Kernel finds the true minimum, though the authors note this is not statistically significant [2305.13998].

A 2025 extension, **SMT-EX**, shifts attention from prediction to interpretability [2503.19496]. SMT-EX is an explainability layer around SMT that adds **SHAP**, **PDP**, and **ICE**, along with Sobol’ indices for continuous-variable problems and conformal prediction [2503.19496]. It is model-agnostic at the SMT level because it only requires access to surrogate predictions, and is designed to work particularly well with SMT’s mixed-categorical GP models [2503.19496].

SMT-EX demonstrates this on a 10-variable wing weight problem and a mixed-categorical cantilever beam bending problem [2503.19496]. For the wing weight case, a GP with squared exponential covariance is trained on 300 points with an 80/20 train/test split and achieves test RMSE \(0.144\) [2503.19496]. For the mixed-categorical cantilever beam case, a mixed-categorical GPR model is trained on 300 samples with an 80/20 split and achieves test RMSE \(10^{-4}\) [2503.19496]. The paper further uses learned categorical correlation matrices from SMT’s mixed GP to show that category levels cluster by thickness or hollowness rather than by gross shape family, which it interprets as physically meaningful structure [2503.19496].

These explainability results reinforce an important characteristic of SMT 2.0: its mixed-variable GP models do not merely accommodate heterogeneous inputs; they also learn internal structures, such as categorical-level correlations, that can themselves be inspected [2503.19496]. This suggests that SMT 2.0’s contribution is not limited to predictive flexibility but also includes a richer structural interpretation of engineering design spaces.

## 7. Comparisons, limitations, and later developments

The SMT 2.0 paper compares the toolbox against BoTorch, Dakota, DiceKriging, KerGP, LVGP, Parmoo, and Spearmint, and argues that SMT 2.0 uniquely combines mixed variables, GD/CR/HH/EHH kernels, hierarchical variables, Python implementation, and BSD licensing [2305.13998]. The authors’ main claim is that many libraries support mixed variables only through simple methods such as Gower distance or continuous relaxation, that KerGP supports richer categorical kernels but is in R, and that no open-source library other than SMT 2.0 supports hierarchical-variable Kriging models of the implemented type [2305.13998].

The paper is nevertheless explicit about limitations. HH and EHH can be much more accurate, but their hyperparameter count grows as
\[
\frac{1}{2}L_i(L_i-1)
\]
per categorical variable, making training costlier and optimization harder [2305.13998]. The dedicated hierarchical kernel derivation assumes **quantitative decreed variables**, and rich mixed or hierarchical models remain bottlenecked by hyperparameter optimization [2305.13998]. Noise support exists but is not the central focus of the main benchmarks [2305.13998].

Later work sharpens both the scope and the constraints of SMT 2.0. The graph-based hierarchical framework emphasizes that many real domains are **heterogeneous**, **tree-structured**, or **DAG-structured**, and that points may not share the same active variables or bounds [2506.22621]. The kernel-framework paper notes that current demonstrations of periodic and compositional kernels are all **one-dimensional**, and warns that the number of hyperparameters multiplies with dimension, making modeling time quickly prohibitive [2507.09694]. SMT-EX, in turn, notes that explanations are only as good as the surrogate and that many explanation methods depend strongly on sampled data distributions [2503.19496].

Comparison with other surrogate-related toolboxes clarifies SMT 2.0’s niche. GTApprox, for example, is presented as an industrial surrogate modeling environment emphasizing automated model selection, hints, tensorized approximations, and workflow-oriented features for medium-scale engineering data [1609.01088]. MATSuMoTo, by contrast, is an optimization engine built around surrogate modeling for expensive black-box global optimization, especially with mixed-integer variables [1404.4261]. SMT 2.0 differs from both: it is less automation-heavy than GTApprox and less optimization-prescriptive than MATSuMoTo, but more oriented toward an open, extensible, research-grade surrogate-modeling ecosystem in Python [2305.13998].

Taken together, these papers present SMT 2.0 as an evolving framework whose 2023 release established native support for **mixed-variable** and **hierarchical-input** Gaussian processes, and whose later extensions broadened this foundation toward **graph-structured design spaces**, **composable kernels**, and **post-fit explainability** [2305.13998; 2506.22621; 2507.09694; 2503.19496]. A plausible implication is that SMT 2.0’s defining contribution is not a single surrogate family, but a unifying software and methodological layer for surrogate modeling on structured engineering domains.

Source: https://www.emergentmind.com/topics/surrogate-modeling-toolbox-smt-2-0