自适应离散化算法：高效求解离散空间最优实验设计问题

1. 项目概述：当最优设计遇上自适应离散化

在工程优化、药物研发、传感器网络布局乃至机器学习模型训练中，我们常常面临一个经典问题：如何用最少的实验次数或数据点，获取最丰富、最可靠的信息？这就是最优实验设计的核心目标。传统方法，比如经典的D-最优、A-最优准则，往往假设实验点可以从一个连续的设计空间（比如某个温度区间、浓度范围）中任意选取。但在现实中，很多情况是离散的——你只能在有限的几个预设位置安装传感器，或者只能在特定的几个配方比例下进行合成实验。这就引出了离散空间上的最优设计问题。

然而，当这个离散集合本身非常庞大，甚至理论上是一个连续空间但我们只能计算有限个候选点时，问题就变得棘手了。穷举所有可能性计算量爆炸，随机采样又可能错过关键区域。这时，“自适应离散化算法”就登场了。它不是一个固定的算法，而是一类策略的核心思想：我们并不需要一开始就面对整个庞大的候选集或连续空间，而是从一个粗糙的、稀疏的离散点集开始，根据当前最优设计计算的结果，智能地、有方向地在最需要的地方（比如信息量最大或当前设计最薄弱的区域）添加新的候选点，逐步精细化这个离散集合，直至满足收敛条件。

我最近在为一个化工反应器的在线监测点优化项目工作时，就深度应用并改造了这套方法。项目要求我们在一个三维的反应器表面选择不超过10个测温点，使得基于这些点数据重建整个温度场的误差最小。反应器表面是连续的，但计算资源有限，我们无法处理无限个可能点。自适应离散化让我们从一个简单的20个点的初始网格开始，迭代了不到10轮，就锁定了一个高性能的传感器布局方案，计算效率比传统均匀加密网格方法提升了数倍。今天，我就结合这个实战项目，拆解自适应离散化算法在最优实验设计中的核心原理、收敛性保证的关键，以及如何将其应用到你的实际问题中。

2. 算法核心思想与框架拆解

2.1 什么是最优实验设计？从连续到离散的挑战

首先，我们统一一下问题表述。假设我们有一个参数化的模型，其响应 $y$ 与输入变量 $x$（位于空间 $\chi$ 中）和未知参数 $\theta$ 有关，并伴有随机误差。费雪信息矩阵 $M(\xi, \theta)$ 衡量了在实验设计 $\xi$（一种在 $\chi$ 上的概率测度，表示在不同点重复实验的比例）下，我们对参数 $\theta$ 估计的不确定性。最优实验设计的目标就是找到一个设计 $\xi^*$，最大化某个关于信息矩阵 $M$ 的标量函数 $\Phi(M)$，例如：

• D-最优：最大化 $\log \det(M)$，相当于最小化参数估计的置信椭球体积。
• A-最优：最小化 $\text{trace}(M^{-1})$，即最小化参数估计的方差和。
• E-最优：最大化 $M$ 的最小特征值，提升最差估计方向上的精度。

在连续设计空间 $\chi$ 上，存在著名的等价性定理，它给出了一个设计是 $\Phi$-最优的充要条件。这个定理引入了一个关键函数——敏感性函数$\psi(x, \xi)$。对于 D-最优设计，其敏感性函数为 $\psi(x, \xi) = f(x)^T M(\xi)^{-1} f(x) - p$，其中 $f(x)$ 是回归向量，$p$ 是参数维度。等价性定理指出：一个设计 $\xi^$ 是 D-最优的，当且仅当在其支撑集（即设计点）上 $\psi(x, \xi^) = 0$，并且在所有 $x \in \chi$ 上 $\psi(x, \xi^*) \le 0$。

注意：这里的“连续设计”指的是设计测度 $\xi$ 可以在空间上连续分布，但实际实施时，我们最终得到的还是一组离散的实验点及其重复次数。连续理论的价值在于它提供了全局最优性的判别标准。

当我们转向离散候选集 $S_n = {x_1, ..., x_n}$ 时，问题变为一个有限维的凸优化问题：在 $n$ 个点上分配权重（实验比例）。虽然可解，但 $n$ 很大时（例如百万量级），构建和求解的复杂度依然很高。更根本的挑战是，如果 $S_n$ 本身没有很好地覆盖 $\chi$，那么在这个离散集上找到的“最优”设计，可能离全局连续最优设计相差甚远。自适应离散化的动机正在于此：我们不想预先固定一个可能很差劲的 $S_n$，而是希望动态地构建它。

2.2 自适应离散化的基本工作流程

自适应离散化算法是一个迭代框架，其核心流程可以概括为以下四步：

1. 初始化：从一个粗糙的离散候选集 $S^{(0)}$ 开始（例如，一个稀疏的网格，或随机选取的少量点）。设定收敛阈值 $\epsilon$。
2. 求解当前离散问题：在当前候选集 $S^{(k)}$ 上，求解最优实验设计问题，得到当前最优设计 $\xi^{(k)}$ 及其对应的信息矩阵 $M^{(k)}$。
3. 评估与细化：计算当前设计 $\xi^{(k)}$ 的敏感性函数 $\psi(x, \xi^{(k)})$ 在整个连续空间 $\chi$ 或一个密集的检验集上的值。找到那些 $\psi(x, \xi^{(k)})$ 值最大的区域（即最违反最优性条件的区域）。
4. 更新候选集：在这些“最有潜力”的区域，添加新的点到候选集 $S^{(k)}$ 中，形成 $S^{(k+1)}$。返回第2步，直到满足收敛条件，例如 $\max_{x \in \chi} \psi(x, \xi^{(k)}) < \epsilon$。

这个过程的直觉非常清晰：敏感性函数 $\psi(x, \xi)$ 的值衡量了在点 $x$ 处增加实验权重所能带来的“信息收益”。值越大，说明该点对提升当前设计的效率越重要。算法就像一个有经验的勘探者，不是漫无目的地到处钻井，而是根据已有的探测结果（当前设计），不断去那些最可能蕴藏富矿（高信息量）的地方进行加密勘探。

2.3 方案选型：几种常见的自适应策略

在实际实现中，“如何添加新点”有不同的策略，主要分为两类：

2.3.1 基于全局搜索的加密这是最直接的方法。在第 $k$ 轮迭代中，我们在整个空间 $\chi$ 上（或一个非常密集的全局网格上）评估 $\psi(x, \xi^{(k)})$。然后选择 $\psi$ 值最大的一个或几个点，将其加入候选集。

• 优点：理论上能保证找到全局最需要加密的点，收敛性分析相对直观。
• 缺点：每一步都需要进行全局优化（求 $\psi(x)$ 的最大值），当 $\chi$ 维度较高或 $\psi(x)$ 计算复杂时，这一步本身计算成本可能很高。

2.3.2 基于局部模型的加密为了规避全局搜索的成本，我们可以构建局部模型。例如，在当前设计 $\xi^{(k)}$ 的支撑点附近，或者在上一步添加的新点附近，进行局部加密（如细分网格）。也可以利用 $\psi(x)$ 的导数信息，在其梯度较大的方向进行加密。

• 优点：避免了昂贵的全局搜索，每一步的计算量小。
• 缺点：可能陷入局部区域，需要更谨慎的收敛性判断。适用于 $\psi(x)$ 比较光滑，且最优设计支撑集可能集中在几个局部区域的问题。

在我的反应器监测项目中，我采用了混合策略。前几轮使用低成本的拉丁超立方采样生成一批点进行全局评估，快速定位敏感区域；在后期，当敏感区域相对集中后，切换到在该区域的精细网格上进行局部搜索和加密，大幅减少了计算量。

3. 收敛性分析：算法为什么有效？

算法的实用性必须建立在坚实的理论基础上，即我们必须知道它最终能否收敛到一个（至少是局部）最优设计。收敛性分析是理解算法行为、指导参数设置（如阈值 $\epsilon$）的关键。

3.1 收敛性的核心：单调性与有界性

对于基于全局搜索加密的自适应离散化算法，其收敛性证明通常遵循以下思路：

1. 最优性度量的单调改进：定义 $g^{(k)} = \max_{x \in \chi} \psi(x, \xi^{(k)})$。根据等价性定理，$g^{(k)} \ge 0$，且当且仅当 $\xi^{(k)}$ 是连续空间上的最优设计时，$g^{(k)} = 0$。可以证明，在每一步添加 $\psi$ 最大值点后，下一轮设计的信息矩阵行列式（对于 D-最优）会严格增大，或者 $g^{(k)}$ 会非增。这保证了算法是在朝着更优的方向前进。

2. 候选集增长的有限性：一个关键点是，算法不需要无限添加点。对于线性或广义线性模型，在连续空间 $\chi$ 紧致的条件下，存在一个有限的“最大必要候选集”。一旦算法添加的点覆盖了这个集合的某个 $\delta$-网，那么得到的设计就非常接近最优了。这保证了算法会在有限步内达到 $\epsilon$-最优。

3. 收敛速率：在理想条件下（如模型线性、$\chi$ 凸），可以证明 $g^{(k)}$ 以 $O(1/k)$ 或类似的速率下降。这为我们设置停止准则提供了量化参考：如果迭代很多步后 $g^{(k)}$ 下降缓慢，可能意味着已经接近极限。

实操心得：在工程中，我们很少能严格证明收敛速率。更实用的做法是监控两个指标：一是 $g^{(k)}$ 的变化，当其小于阈值且连续几轮不再显著下降时停止；二是观察新添加点的位置，如果新点总是密集地出现在同一小片区域，可能意味着该区域存在一个真实最优设计的支撑点，算法正在逼近它。

3.2 影响收敛的关键参数与陷阱

1. 初始候选集 $S^{(0)}$：如果初始集完全错过了最优设计的支撑区域，算法可能需要很多轮才能“发现”那片区域。一个好的实践是，初始集至少应均匀覆盖空间，并包含边界点。对于复杂空间，可以使用空间填充设计（如拉丁超立方）初始化。

2. 加密点的数量：每轮是添加一个点还是多个点？添加一个点保证严格单调性，但可能收敛慢。批量添加可以加速，但可能引入“浪费”的点。我的经验是，在早期可以批量添加（如每轮加5-10个点）以快速探索，在后期改为单点添加以精细调整。

3. 收敛阈值 $\epsilon$：设置得太小，会导致不必要的迭代，可能陷入对数值误差的追逐。设置得太大，可能得到次优解。一个常用的启发式方法是设 $\epsilon = 0.01 * p$（对于 D-最优），其中 $p$ 是参数维度。也可以观察 $\Phi(M)$ 值的变化，当其相对提升小于千分之一时停止。

常见陷阱：

• 数值误差导致的早停：计算 $\psi(x)$ 涉及矩阵求逆，当 $M$ 病态时，$\psi(x)$ 的计算可能不稳定，导致 $g^{(k)}$ 被低估而提前停止。解决方法是使用稳定的线性代数库（如 Cholesky 分解求逆），并加入正则化项。
• 陷入“平庸”区域：对于多峰模型，$\psi(x)$ 可能有多个局部极大值。算法可能被第一个发现的局部极大值吸引，不断在其周围加密，而错过了全局更好的区域。引入一定的随机探索机制（如以一定概率添加非最大 $\psi$ 值点）有助于缓解此问题。

4. 实战实现：从理论到代码

让我们以一个具体的例子——在一维区间 $[-1, 1]$ 上为二次多项式模型 $y = \theta_0 + \theta_1 x + \theta_2 x^2 + \epsilon$ 寻找 D-最优设计——来演示实现过程。连续理论告诉我们，3参数的最优设计应该在3个点上分配权重，对于对称区间，最优设计是等权重地分布在 $-1, 0, 1$ 这三个点。

4.1 环境准备与工具选型

我们使用 Python 进行实现。核心库包括：

• NumPy&SciPy：用于数值计算、线性代数、优化。
• CVXPY：一个优秀的凸优化建模库，可以优雅地描述和求解最优设计问题。
• Matplotlib：用于可视化。

首先安装必要的库：

pip install numpy scipy cvxpy matplotlib

4.2 算法核心模块实现

我们将算法分解为几个函数：

import numpy as np import cvxpy as cp import matplotlib.pyplot as plt def regression_vector(x): """对于二次模型，返回回归向量 f(x) = [1, x, x^2]^T""" return np.array([1, x, x**2]) def sensitivity_function(x, design_weights, candidate_points): """ 计算在点x处的敏感性函数 psi(x)。 参数： design_weights: 在当前候选集上的最优权重向量 candidate_points: 当前候选点集 """ p = 3 # 参数维度 # 构建信息矩阵 M M = np.zeros((p, p)) for w, point in zip(design_weights, candidate_points): f = regression_vector(point) M += w * np.outer(f, f) # w * f * f^T # 计算 psi(x) = f(x)^T * M^{-1} * f(x) - p f_x = regression_vector(x) # 使用稳定的求逆方法 try: Minv = np.linalg.inv(M) psi = f_x.T @ Minv @ f_x - p except np.linalg.LinAlgError: # 如果M奇异，赋予一个很大的psi值，促使算法在该区域添加点 psi = 1e6 return psi def solve_optimal_design(candidate_points): """ 在给定的离散候选点集上求解D-最优设计。 返回最优权重向量。 """ n = len(candidate_points) p = 3 # 变量：权重 w >= 0, 且 sum(w) = 1 w = cp.Variable(n) constraints = [w >= 0, cp.sum(w) == 1] # 构建信息矩阵 F = np.array([regression_vector(xi) for xi in candidate_points]) # n x p 矩阵 # 目标：最大化 log det (sum_i w_i * f_i * f_i^T) # CVXPY 支持 log_det 原子函数，但需要将信息矩阵表达为仿射形式。 # 一个等价且更稳定的方法是：最大化 det(M)^{1/p}，这等价于D-最优。 # 我们使用常见的凸形式：最小化 -log_det(M) M = cp.sum([w[i] * cp.outer(F[i], F[i]) for i in range(n)], axis=0) objective = cp.Minimize(-cp.log_det(M)) prob = cp.Problem(objective, constraints) try: prob.solve(solver=cp.SCS, verbose=False, max_iters=10000) # SCS 可以处理半定规划 if w.value is not None: # 由于数值误差，将极小的权重设为0 weights = np.maximum(w.value, 0) weights = weights / np.sum(weights) # 重新归一化 return weights else: return np.ones(n) / n # 求解失败，返回均匀权重 except: return np.ones(n) / n def adaptive_discretization(initial_points, epsilon=0.05, max_iter=50): """ 自适应离散化主算法。 参数： initial_points: 初始候选点列表 epsilon: 收敛阈值 max_iter: 最大迭代次数 """ candidate_points = np.array(initial_points) history = {'points': [], 'weights': [], 'max_psi': []} for iter in range(max_iter): print(f"Iteration {iter+1}: Candidate set size = {len(candidate_points)}") # 步骤1: 在当前候选集上求解最优设计 weights = solve_optimal_design(candidate_points) # 记录历史 history['points'].append(candidate_points.copy()) history['weights'].append(weights.copy()) # 步骤2: 在密集的检验网格上评估敏感性函数，寻找最大值点 # 注意：这里为了演示，在一维区间上均匀采样。高维问题需用更高效的全局优化器。 test_grid = np.linspace(-1, 1, 1001) psi_values = np.array([sensitivity_function(x, weights, candidate_points) for x in test_grid]) max_psi = np.max(psi_values) x_max = test_grid[np.argmax(psi_values)] history['max_psi'].append(max_psi) print(f" Max sensitivity psi_max = {max_psi:.4f} at x = {x_max:.4f}") # 步骤3: 收敛判断 if max_psi < epsilon: print(f"Converged after {iter+1} iterations!") break # 步骤4: 添加最大值点（如果该点不在候选集中） if not np.any(np.abs(candidate_points - x_max) < 1e-5): candidate_points = np.append(candidate_points, x_max) print(f" Added new point: {x_max:.4f}") else: print(f" Maximum point {x_max:.4f} already in candidate set.") # 如果最大值点已在集合中，可以考虑在附近添加一个点，防止停滞 x_new = x_max + 0.01 * (np.random.rand() - 0.5) # 添加一个微小扰动 candidate_points = np.append(candidate_points, x_new) print(f" Added perturbed point: {x_new:.4f}") return candidate_points, weights, history

4.3 运行实例与结果分析

现在，让我们从一个非常粗糙的初始集开始运行算法：

# 初始化：只从边界开始 initial_pts = np.array([-1.0, 1.0]) # 只有两个边界点 epsilon = 0.01 candidate_points_final, weights_final, history = adaptive_discretization(initial_pts, epsilon=epsilon, max_iter=15) # 可视化结果 fig, axes = plt.subplots(2, 2, figsize=(12, 10)) # 图1: 最终设计点及权重 ax = axes[0, 0] ax.bar(candidate_points_final, weights_final, width=0.05, alpha=0.7, color='skyblue', edgecolor='black') ax.set_xlabel('Design Space (x)') ax.set_ylabel('Optimal Weight') ax.set_title(f'Final Optimal Design (Total {len(candidate_points_final)} candidate points)') ax.grid(True, linestyle='--', alpha=0.5) # 图2: 最大敏感性值随迭代的变化 ax = axes[0, 1] iterations = range(1, len(history['max_psi'])+1) ax.plot(iterations, history['max_psi'], marker='o', linestyle='-', linewidth=2) ax.axhline(y=epsilon, color='r', linestyle='--', label=f'Threshold (ε={epsilon})') ax.set_xlabel('Iteration') ax.set_ylabel('Max Sensitivity ψ_max') ax.set_title('Convergence of Adaptive Algorithm') ax.legend() ax.grid(True, linestyle='--', alpha=0.5) ax.set_yscale('log') # 对数尺度更易观察收敛 # 图3: 候选点集的增长 ax = axes[1, 0] for i, pts in enumerate(history['points']): ax.scatter(pts, np.ones_like(pts) * i, s=10, alpha=0.6, label=f'Iter {i+1}' if i < 3 else "") ax.set_xlabel('Candidate Points') ax.set_ylabel('Iteration') ax.set_title('Evolution of Candidate Set') ax.grid(True, linestyle='--', alpha=0.5) ax.legend(loc='upper right') # 图4: 最后一轮迭代的敏感性函数 ax = axes[1, 1] test_grid = np.linspace(-1, 1, 1001) final_weights = history['weights'][-1] final_points = history['points'][-1] psi_final = np.array([sensitivity_function(x, final_weights, final_points) for x in test_grid]) ax.plot(test_grid, psi_final, linewidth=2) ax.fill_between(test_grid, psi_final, 0, where=(psi_final > 0), alpha=0.3, color='red', label='ψ(x) > 0') ax.axhline(y=0, color='k', linestyle='-', linewidth=0.5) # 标记设计点 design_mask = final_weights > 1e-4 design_pts = final_points[design_mask] ax.scatter(design_pts, np.zeros_like(design_pts), color='green', s=100, zorder=5, label='Design Points (weight>0)') ax.set_xlabel('x') ax.set_ylabel('Sensitivity ψ(x)') ax.set_title('Sensitivity Function at Convergence') ax.legend() ax.grid(True, linestyle='--', alpha=0.5) plt.tight_layout() plt.show() # 打印最终设计 print("\n=== Final Optimal Design ===") for pt, w in zip(candidate_points_final, weights_final): if w > 1e-4: print(f" Point x = {pt:7.4f}, Weight = {w:.4f}")

运行这段代码，你会观察到算法如何工作。初始只有两个边界点[-1, 1]，设计权重会平分。计算出的敏感性函数 $\psi(x)$ 会在中点x=0附近取得最大值，因为该点提供了关于二次项 $\theta_2$ 的关键信息，而当前设计缺少它。于是算法将x=0加入候选集。下一轮求解后，权重会自然调整到接近[-1, 0, 1]各1/3的最优设计。随后，$\psi(x)$ 的最大值会迅速下降至阈值以下，算法收敛。

实操心得：在实际编码中，凸优化求解器（如CVXPY调用的SCS或ECOS）对于中等规模问题非常可靠。但对于大规模候选集（成千上万个点），构建 $M$ 矩阵的求和操作会成为瓶颈。此时，可以考虑利用问题的稀疏性（最优设计通常只在一小部分点上有非零权重），使用基于坐标下降或交换算法的专用求解器来替代通用的凸优化求解器，可以极大提升效率。

5. 高级话题与工程应用扩展

5.1 处理非线性模型与序贯设计

上述例子基于线性模型（参数 $\theta$ 以线性形式影响响应）。对于非线性模型（如 $y = \exp(-\theta x)$），信息矩阵 $M$ 依赖于未知参数 $\theta$ 的真值，这构成了一个循环：我们需要最优设计来精确估计 $\theta$，但设计本身又依赖于 $\theta$。这时通常采用局部最优设计（基于一个初始参数猜测 $\theta_0$）或贝叶斯最优设计（考虑参数先验分布）。自适应离散化算法依然适用，只是敏感性函数 $\psi(x, \xi)$ 的定义会变得更加复杂，涉及模型的一阶或二阶导数。

在序贯实验设计中，我们一边实验一边更新设计。自适应离散化可以自然地融入这个过程：每获得一个新的实验数据点，就更新参数估计 $\hat{\theta}$，然后基于新的 $\hat{\theta}$ 重新运行一轮自适应离散化，为下一个实验点提供建议。这实现了真正的“自适应”和“在线”学习。

5.2 高维空间与计算优化

当设计空间 $\chi$ 是高维（例如 >5 维）时，全局搜索 $\psi(x)$ 的最大值变得不可行。此时需要：

1. 高效的全局优化器：使用诸如贝叶斯优化、DIRECT 等算法来寻找 $\psi(x)$ 的近似全局最大值点。
2. 稀疏初始化和智能加密：初始候选集使用高维空间填充设计。加密时，不是添加单个点，而是在一个局部区域（如 $\psi(x)$ 值较高的一个超立方体内）批量添加一组点，以探索该区域。
3. 降维技术：如果输入变量间存在相关性或模型对某些维度不敏感，可先使用主成分分析（PCA）或活性子空间方法进行降维，在低维空间进行设计，再映射回原空间。

在我的三维反应器项目中，空间维度不算太高，但 $\psi(x)$ 的计算涉及计算流体动力学（CFD）模拟，非常昂贵。我采用了一种代理模型策略：用前几轮昂贵模拟的数据，训练一个高斯过程（GP）模型来快速预测新点上的 $\psi(x)$ 值。算法在 GP 预测的 $\psi(x)$ 表面上进行优化和加密，大幅降低了计算成本。

5.3 与其他优化方法的对比

• 与直接连续优化对比：连续优化方法（如基于梯度的算法）直接优化设计测度 $\xi$，但需要处理测度本身的参数化，可能陷入局部最优。自适应离散化将问题转化为一系列离散优化，更稳定，且易于结合离散约束。
• 与交换算法对比：经典的 Fedorov 交换算法也是在固定候选集上操作。自适应离散化通过动态扩充候选集，解决了交换算法对初始候选集质量依赖过强的问题，通常能发现更优的设计。
• 与随机采样对比：纯粹的随机采样（如蒙特卡洛）没有导向性，效率低下。自适应离散化是一种有信息的、导向性的采样，效率更高。

6. 常见问题与调试技巧实录

在实际应用中，你可能会遇到以下典型问题：

问题1：算法迭代很多步也不收敛，$\psi_{max}$ 始终在较高水平波动。

• 可能原因1：模型错误或参数不可识别。检查你的模型是否过度参数化，或者信息矩阵 $M$ 是否接近奇异。这会导致 $\psi(x)$ 计算不稳定。
  • 排查：在迭代开始时，打印信息矩阵 $M$ 的条件数。如果条件数巨大（如 >1e10），说明模型在该设计下病态。
  • 解决：考虑简化模型，或为 $M$ 添加一个小的正则化项 $M + \lambda I$ 再求逆。
• 可能原因2：加密策略过于激进或保守。如果每轮添加的点太多，可能引入噪声；如果只添加一个点，在高维空间可能探索太慢。
  • 排查：观察添加点的历史。它们是否在空间里跳跃，没有形成聚集？
  • 解决：调整每轮添加点的数量。尝试“探索-利用”平衡策略：前期批量添加进行探索，后期单点添加进行利用。

问题2：最终设计权重分散在很多点上，而不是集中在少数几个点。

• 可能原因：收敛阈值 $\epsilon$ 设置过大。算法过早停止，没有找到真正的稀疏解。
• 解决：减小 $\epsilon$，让算法继续运行。同时，在求解凸优化问题时，可以尝试在目标函数中加入对权重 $w$ 的 $L_1$ 正则化项（如 $\lambda \sum |w_i|$），以直接促进稀疏性。但要注意，这可能会轻微偏离严格的 D-最优准则。

问题3：算法找到了一个设计，但实际实验效果不佳。

• 可能原因：模型失配。最优实验设计严重依赖于假设的模型。如果真实过程与你的模型相差甚远，那么基于模型的最优设计可能在实际中并不“最优”。
• 解决：采用更稳健的设计准则，如贝叶斯设计（考虑模型不确定性），或使用模型失配容忍度更高的设计（如最大熵设计）。在可能的情况下，使用序贯设计，让模型随着实验数据积累而更新。

问题4：计算速度太慢，尤其是候选集很大时。

• 优化技巧：
  1. 热启动：在迭代 $k+1$ 时，使用第 $k$ 轮的最优权重作为求解器的初始值，通常能加速收敛。
  2. 问题缩放：确保设计空间 $\chi$ 的各维度量纲一致，最好归一化到 $[0,1]$ 区间，这能提高优化求解器的数值稳定性。
  3. 并行计算：评估 $\psi(x)$ 在不同点上的值是相互独立的，可以很容易地并行化。
  4. 使用专业求解器：对于纯粹的 D-最优设计，有专门的算法（如 multiplicative algorithm）比通用的凸优化求解器更快。

最后，记住自适应离散化是一个强大的框架，而不是一个固定的配方。你需要根据具体问题的特点（模型线性/非线性、空间维度、计算成本）来调整其各个组件：初始集的生成、加密策略、收敛判断、以及底层的最优设计求解器。它把寻找最优设计这个复杂问题，分解成了“优化”和“探索”两个交替进行的子问题，提供了一种系统且高效的解决路径。在我经历的项目中，这种思路的成功应用，往往比找到一个“完美”的算法参数设置更重要。