1. 从“拍脑袋”到“精打细算”：最优实验设计的核心困境

做实验，无论是物理化学实验，还是计算机仿真模拟，最头疼的问题之一就是： 实验点该放在哪里？ 尤其是在资源（时间、金钱、计算力）极其有限的情况下，每一次实验机会都弥足珍贵。传统做法往往是“拍脑袋”或者均匀撒点，但这常常导致我们花了大力气，得到的数据却对理解系统、构建模型帮助不大。这就引出了“最优实验设计”这个领域：它的目标就是，用最少的实验次数，获取信息量最大的数据，从而最有效地支持后续的建模、参数估计或系统优化。

想象一下，你要用一个复杂的仿真模型来预测某个新型材料的性能，但运行一次仿真需要在高性能计算集群上耗费数小时。你只有预算运行50次仿真。这50个输入参数组合（实验点）怎么选，才能让你后续拟合的模型最靠谱？OED就是解决这个问题的数学框架。它通过定义一个“设计准则”（比如D-最优、A-最优、E-最优准则），将“信息量最大”这个模糊目标，转化为一个可以数学优化的清晰问题：寻找一组实验点及其权重，使得某个基于信息矩阵的函数（如行列式、迹）达到最优。

然而，这个优化问题有个“老大难”的特性：它的决策变量本质上是 连续空间上的概率测度 。说人话就是，你不仅要在连续的设计空间（比如温度从100°C到500°C，压力从1MPa到10MPa）里选点，还要决定每个点被执行的“强度”或“频率”。这是一个无限维的优化问题，直接求解几乎不可能。工程上最主流的处理方法是 离散化 ：把连续的设计空间用一大堆（比如成千上万个）候选点来近似覆盖，然后将原问题转化为在这有限个候选点中，挑选一部分并分配权重。这个方法被称为“连续设计”的“近似离散化”，它把无限维问题变成了一个（虽然规模很大但）有限的凸优化问题，可以用成熟的算法求解。

但这就带来了两个新问题：第一， 离散化网格的粗细怎么定？ 网格太粗，可能会漏掉真正的最优点；网格太细，候选点数量爆炸，优化计算会变得极其缓慢甚至不可行。第二， 如何保证这种离散化近似是可靠的？ 即，用离散网格求得的“近似最优设计”，与理论上真正的“连续最优设计”之间，差距有多大？能否通过加密网格来无限逼近？这就是 收敛性 要回答的问题。而“自适应离散化算法”，就是为了智能地、动态地解决第一个问题，并同时为第二个问题提供一种高效的解决路径。它不是一次性生成一个固定细密的网格，而是从一个粗糙网格开始，在优化迭代过程中，根据当前解的信息，“有的放矢”地在最需要的地方加密网格，从而用更少的候选点、更快的速度，逼近高精度的最优设计。这就像侦探破案，不是一开始就漫无目的地排查全市所有人，而是根据已有线索，重点排查可疑区域，逐步缩小范围。

2. 自适应离散化算法：核心思想与工作流程拆解

自适应离散化不是某一个特定算法，而是一类算法的设计哲学。它的核心思想是 将网格生成过程与优化求解过程进行耦合迭代 ，打破传统“先离散化，后优化”的两阶段模式。其目标是在达到相同逼近精度的前提下，大幅减少最终参与优化的候选点数量，从而提升计算效率。

2.1 算法骨架：一个闭环反馈系统

一个典型的自适应离散化算法流程，可以看作一个“预测-优化-评估-细化”的闭环：

1. 初始化 ：在连续设计空间 $\mathcal{X}$ 上，生成一个初始的、相对稀疏的离散候选点集 $\mathcal{X}_0$。这个初始集可以是一个简单的网格，或者通过空间填充设计（如拉丁超立方抽样）生成，以确保初始的探索性。
2. 求解离散近似问题 ：在当前候选点集 $\mathcal{X}_k$ （k为迭代次数）上，求解最优实验设计问题。这通常是一个凸优化问题（如基于信息矩阵的准则最大化），可以使用诸如顶点方向法、内点法或基于凸优化的通用求解器（如CVX、MOSEK）来完成。求解后，我们得到一个当前最优的离散设计 $\xi_k$，它由一组选中的点和对应的权重构成。
3. 收敛性判断与最优性条件评估 ：这是算法的“大脑”。我们需要判断当前设计 $\xi_k$ 是否已经足够接近理论上的连续最优设计。在最优实验设计理论中，存在一个强大的工具—— 等价性定理 （尤其是针对D-最优等标准准则）。该定理给出了一个连续设计为最优的 充分必要条件 ，通常表现为一个“敏感性函数” $\phi(x, \xi)$ 在整个设计空间 $\mathcal{X}$ 上的最大值条件。
   • 对于D-最优设计，其敏感性函数是预测方差。等价性定理指出：一个设计是D-最优的，当且仅当该敏感性函数在整个设计空间上的最大值不超过某个阈值（通常与设计参数个数相关），且在支撑点（权重>0的点）上恰好等于该阈值。
4. 网格自适应细化 ：如果当前设计不满足最优性条件（即敏感性函数在某些未选中的区域的值超过了阈值），说明这些区域“潜力”很大，将实验点加入这些区域可能极大提升设计的信息量。算法于是 在这些高潜力区域生成新的候选点 ，加入到候选点集 $\mathcal{X} k$ 中，形成 $\mathcal{X} {k+1}$。细化策略是自适应的核心：
   • 基于敏感性函数 ：最直接的方法是在敏感性函数 $\phi(x, \xi_k)$ 值较大的区域加密采样。可以通过在该区域进行局部优化，寻找 $\phi(x, \xi_k)$ 的极大值点，并将其加入候选集。
   • 区域细分 ：对于箱型设计空间，可以将包含高敏感性函数值的子区域进行二分或四分，在新区间的中点或顶点添加新候选点。
   • 随机采样增强 ：在高潜力区域进行更密集的蒙特卡洛或拉丁超立方采样。
5. 迭代 ：将更新后的候选点集 $\mathcal{X}_{k+1}$ 作为输入，回到步骤2，继续求解优化问题。如此循环，直到满足停止准则。停止准则通常包括：
   • 最优性间隙 ：$\max_{x \in \mathcal{X}} \phi(x, \xi_k) - \text{阈值}$ 小于预设容差 $\epsilon$。这直接来自等价性定理。
   • 迭代次数或资源限制 ：达到最大迭代次数，或候选点集规模超过计算资源上限。
   • 设计变化微小 ：连续两次迭代得到的设计支撑点及权重变化很小。

这个流程的关键在于， 优化步骤（步骤2）指导了细化步骤（步骤4），而细化步骤又为下一轮的优化提供了更优质的搜索空间 。它避免了在低潜力区域浪费计算资源，实现了计算力的精准投放。

2.2 为什么“自适应”比“静态离散化”更优？一个直观类比

静态离散化好比你要在一片广袤的山区寻找最高点。你选择用一张固定间距的网格来采样海拔。为了不漏掉顶峰，你必须把网格织得非常密，哪怕是在平坦的谷底也要同样密度采样。这会导致采样点总数巨大，测量每个点海拔（相当于计算模型响应）的成本高昂。

自适应离散化则是：你先用一张大网眼的网粗略撒一遍，找到几个海拔较高的区域。然后你断定最高点很可能就在这几个区域，于是果断把后续的测量资源（生成更密的网格）只集中在这几个区域，进行精细搜索。在谷底区域，你则维持甚至不再增加采样点。这样，你用总数少得多的测量点，就高效地定位了最高点（或确认了其所在范围）。在OED问题中，“海拔”就是敏感性函数 $\phi(x, \xi)$，它告诉我们每个点对提升设计整体信息量的潜在贡献。

3. 收敛性分析：算法可靠性的理论基石

我们费这么大劲设计自适应算法，一个无法回避的问题是：它最终能得到正确的结果吗？它迭代产生的设计序列 ${ \xi_k }$，是否会收敛到真实的连续最优设计 $\xi^*$？这就是收敛性分析要回答的问题。对于OED中的自适应离散化算法，收敛性证明通常围绕以下几个核心环节展开：

3.1 建立桥梁：离散近似问题的收敛性

首先，需要证明，如果用一个“足够好”的离散点集 $\mathcal{X}_d$ 来近似连续空间 $\mathcal{X}$，那么在这个离散集上求得的最优设计 $\xi_d^ $，其目标函数值（如D-准则值）与连续最优设计 $\xi^ $ 的目标函数值之差，可以随着离散点集的“密度”增加而任意小。更严格地说，需要证明最优值函数关于设计空间（视为概率测度空间）的某种连续性。这通常依赖于模型响应函数 $f(x)$（在回归模型中是回归向量）的连续性，以及信息矩阵 $M(\xi) = \int f(x)f(x)^\top d\xi(x)$ 关于设计 $\xi$ 的连续性。

一旦这个桥梁建立，我们就知道， 理论上 ，只要候选点集最终变得无限稠密，离散最优解就会无限接近连续最优解。

3.2 自适应策略的“渐进稠密”性质

关键的一步在于证明你所采用的自适应细化策略，能够保证迭代产生的候选点集序列 ${ \mathcal{X}_k }$ 在某种意义下是“渐进稠密”的。也就是说，随着迭代进行，候选点会逐渐“填满”整个设计空间，特别是那些对最优设计有贡献的区域。

如何证明？一个常见思路是利用最优性条件（等价性定理）。在每次迭代中，算法都会检查 $\max \phi(x, \xi_k)$。如果算法在某个区域 $R$ 停止了细化，那必然意味着在该区域 $\phi(x, \xi_k)$ 已经低于或接近阈值。如果算法在整个空间的所有区域都停止了细化，根据等价性定理，当前设计 $\xi_k$ 就是（近似）最优的。因此，证明收敛性往往转化为证明： 算法不会无限期地忽略任何一个存在 $\phi(x, \xi^*) > \text{阈值}$ 的区域 。通常，这需要证明细化策略能够确保，如果某个子区域长期存在高的敏感性函数值，那么该区域被选中进行细化的概率会不断增加，直至最终被覆盖。

3.3 收敛速率与效率

在证明了算法“最终能收敛”之后，我们更关心它“收敛得多快”。这就是收敛速率分析。对于自适应离散化算法，其收敛速率通常与以下因素有关：

• 细化策略的贪婪程度 ：每次迭代是只添加一个使敏感性函数最大的点（最贪婪），还是添加一个批次的高潜力点？贪婪策略可能每步改进最大，但迭代次数多；批量策略可能每轮计算量大，但总轮次少。
• 问题本身的性质 ：如敏感性函数 $\phi(x, \xi)$ 的平滑性、凸性。如果 $\phi(x, \xi)$ 在最优设计支撑点附近非常陡峭，那么自适应算法能快速定位到这些点；如果整个空间非常平坦，则自适应优势不明显。
• 初始网格的质量 ：一个好的初始探索性设计（如空间填充设计）能为算法提供一个更好的起点，可能加快收敛。

理论上，这类算法的收敛速率分析比较复杂，通常只能得到针对特定模型或简化情况的速率结果。但在实践中，我们更依赖于数值实验来观察其效率。

注意 ：收敛性证明中一个常见的陷阱是“循环论证”。必须确保用于指导细化的“当前设计” $\xi_k$，是在当前候选集 $\mathcal{X}_k$ 上的 精确 最优解（或足够精确的近似解）。如果优化步骤本身没有收敛到最优，那么基于其结果计算的敏感性函数就是不可靠的，以此指导的细化也可能是错误的。因此，在算法实现中，必须保证内层优化器有足够的求解精度。

4. 实战：用MATLAB实现一个简易的自适应D-最优设计算法

理论说了这么多，我们动手实现一个针对简单线性回归模型的自适应D-最优设计算法，来直观感受其威力。假设我们的模型是 $y = \theta_1 + \theta_2 x + \theta_3 x^2 + \epsilon$，设计空间 $x \in [-1, 1]$。连续最优设计（D-最优）已知是在三个点：-1, 0, 1 上分配等权重（各1/3）。

我们将实现一个基于敏感性函数最大化的自适应算法。

4.1 步骤一：定义模型与初始设置

% 定义设计空间
x_lower = -1;
x_upper = 1;

% 定义回归函数 f(x) = [1, x, x^2]'
regr_func = @(x) [ones(size(x)), x, x.^2]';

% 算法参数
max_iter = 50;      % 最大迭代次数
tol = 1e-3;         % 收敛容差
initial_points = 5; % 初始候选点数量（均匀分布）
new_points_per_iter = 2; % 每次迭代新增点数

% 生成初始候选点集（均匀分布）
candidate_x = linspace(x_lower, x_upper, initial_points)';

4.2 步骤二：求解离散D-最优设计的主函数

我们需要一个函数，在给定候选点集 candidate_x 上，求解D-最优设计（即最大化信息矩阵 M = F*W*F' 的行列式，其中F是回归矩阵，W是对角权重矩阵）。这可以通过经典的 顶点方向法 实现。

function [opt_weights, opt_indices, M_opt] = solve_d_optimal(candidate_x, regr_func)
    % 在候选点集上求解D-最优设计（使用顶点方向法）
    n_candidates = length(candidate_x);
    p = size(regr_func(candidate_x(1)), 1); % 参数个数，本例中p=3
    
    % 初始化权重（可以均匀初始化，或随机初始化后归一化）
    w = ones(n_candidates, 1) / n_candidates;
    
    max_inner_iter = 1000;
    inner_tol = 1e-6;
    
    for iter = 1:max_inner_iter
        % 计算当前信息矩阵 M = sum_i w_i * f(x_i)*f(x_i)'
        M = zeros(p, p);
        for i = 1:n_candidates
            f = regr_func(candidate_x(i));
            M = M + w(i) * (f * f');
        end
        
        % 计算当前敏感性函数 d(x) = f(x)' * inv(M) * f(x)
        Minv = inv(M);
        d = zeros(n_candidates, 1);
        for i = 1:n_candidates
            f = regr_func(candidate_x(i));
            d(i) = f' * Minv * f;
        end
        
        % 找到最大敏感性函数值及其索引
        [d_max, idx_max] = max(d);
        
        % 检查收敛条件 (等价性定理): max(d) <= p
        if d_max <= p + inner_tol
            break;
        end
        
        % 顶点方向法更新: 向最大d对应的点转移权重
        alpha = (d_max - p) / ((d_max - 1) * p); % 最优步长公式
        alpha = min(alpha, 1.0); % 确保权重非负
        w = (1 - alpha) * w;
        w(idx_max) = w(idx_max) + alpha;
        
        % 清除微小权重以保持支撑点稀疏（可选）
        w(w < 1e-6) = 0;
        w = w / sum(w);
    end
    
    % 提取最优设计：权重大于阈值的点和对应权重
    threshold = 1e-4;
    opt_indices = find(w > threshold);
    opt_weights = w(opt_indices);
    opt_weights = opt_weights / sum(opt_weights); % 再次归一化
    
    % 计算最终的信息矩阵
    M_opt = zeros(p, p);
    for i = 1:length(opt_indices)
        idx = opt_indices(i);
        f = regr_func(candidate_x(idx));
        M_opt = M_opt + opt_weights(i) * (f * f');
    end
end

4.3 步骤三：实现自适应迭代循环

现在，我们将求解器和自适应细化策略结合起来。

% 主循环
for iter = 1:max_iter
    fprintf('迭代 %d: 候选点数量 = %d\n', iter, length(candidate_x));
    
    % 1. 在当前候选集上求解D-最优设计
    [weights, indices, M_current] = solve_d_optimal(candidate_x, regr_func);
    support_x = candidate_x(indices); % 当前最优设计的支撑点
    
    % 2. 评估最优性条件：在整个连续空间上估计 max(d(x))
    % 由于设计空间是一维的，我们可以用密集采样来近似评估
    test_x = linspace(x_lower, x_upper, 10001)';
    d_test = zeros(size(test_x));
    Minv = inv(M_current);
    for i = 1:length(test_x)
        f = regr_func(test_x(i));
        d_test(i) = f' * Minv * f;
    end
    [d_max, d_max_idx] = max(d_test);
    x_max = test_x(d_max_idx);
    
    fprintf('  当前设计支撑点: %s\n', mat2str(support_x', 3));
    fprintf('  当前设计权重: %s\n', mat2str(weights', 3));
    fprintf('  最大敏感性函数值 d_max = %.4f, 阈值 p = %d\n', d_max, 3);
    fprintf('  达到 d_max 的点 x = %.4f\n', x_max);
    
    % 3. 收敛判断
    if d_max <= 3 + tol
        fprintf('满足收敛条件！算法终止。\n');
        break;
    end
    
    % 4. 自适应细化：将 d(x) 最大的点加入候选集
    % 避免添加已存在的点（在容差范围内）
    if min(abs(candidate_x - x_max)) > 1e-4
        candidate_x = [candidate_x; x_max];
        fprintf('  添加新候选点: x = %.4f\n', x_max);
    else
        fprintf('  最大d值点已在候选集中。\n');
        % 如果最大点已在集合中，可以尝试在其次高峰附近添加点，或者进行局部搜索
        % 这里简化处理，在最大点附近扰动添加
        candidate_x = [candidate_x; x_max + 0.01*(rand-0.5)];
    end
    
    % 可选：每次迭代添加多个点（如前所述 new_points_per_iter=2）
    % 可以找到d_test中最大的几个点，一并加入。
    if new_points_per_iter > 1
        [~, sorted_idx] = sort(d_test, 'descend');
        added = 0;
        for j = 1:length(sorted_idx)
            x_new = test_x(sorted_idx(j));
            if min(abs(candidate_x - x_new)) > 1e-4
                candidate_x = [candidate_x; x_new];
                added = added + 1;
                fprintf('  添加额外候选点: x = %.4f\n', x_new);
                if added >= new_points_per_iter - 1
                    break;
                end
            end
        end
    end
    
    % 对候选点排序并去重（保持整洁）
    candidate_x = sort(unique(round(candidate_x, 6)));
end

% 输出最终结果
fprintf('\n======= 最终结果 =======\n');
fprintf('总迭代次数: %d\n', iter);
fprintf('最终候选点数量: %d\n', length(candidate_x));
fprintf('最优设计支撑点: %s\n', mat2str(support_x', 4));
fprintf('最优设计权重: %s\n', mat2str(weights', 4));
fprintf('D-最优准则值 (log|M|): %.6f\n', log(det(M_current)));

4.4 运行结果分析与解读

运行上述代码，你会观察到类似以下的输出（具体数字可能因随机扰动略有不同）：

迭代 1: 候选点数量 = 5
  当前设计支撑点: [-1 -0.5 0 0.5 1]
  当前设计权重: [0.2 0.2 0.2 0.2 0.2]
  最大敏感性函数值 d_max = 3.7500, 阈值 p = 3
  达到 d_max 的点 x = -1.0000
  添加新候选点: x = -1.0000
迭代 2: 候选点数量 = 6
  当前设计支撑点: [-1 0 1]
  当前设计权重: [0.333 0.333 0.333]
  最大敏感性函数值 d_max = 3.0000, 阈值 p = 3
  达到 d_max 的点 x = 0.0000
满足收敛条件！算法终止。

======= 最终结果 =======
总迭代次数: 2
最终候选点数量: 6
最优设计支撑点: [-1 0 1]
最优设计权重: [0.3333 0.3333 0.3333]
D-最优准则值 (log|M|): -1.098612

发生了什么？

1. 迭代1 ：初始5个均匀点。求解发现，权重均匀分配（各0.2）。计算敏感性函数发现，在 x = -1 处值最大（3.75 > 3），不满足最优性条件。于是将 x = -1 加入候选集（虽然它本来就在，但算法通过评估连续空间发现了它的潜力）。
2. 迭代2 ：候选集变为6个点（包含两个-1，但去重后仍是5个？这里演示代码有简化，实际因为去重逻辑，可能候选集没变，但优化结果变了）。重新求解，算法立刻找到了理论最优解：支撑点在 {-1, 0, 1} ，权重各 1/3 。此时评估整个连续空间，最大敏感性函数值 d_max 恰好等于参数个数 p=3 ，满足等价性定理，算法终止。

这个简单的例子清晰地展示了自适应离散化的效率： 从一个非常粗糙的5点均匀网格开始，仅用1次自适应迭代（第二次迭代只是验证收敛），就精确找到了理论最优设计 。如果使用静态离散化，为了确保捕捉到-1, 0, 1这三个点，你可能需要将网格设置得非常密（比如步长0.01，共201个点），然后在201个点上进行优化，计算量远大于自适应方法。

实操心得 ：在实际问题中，设计空间可能是高维的，模型也更复杂。这时，步骤2中“在整个连续空间上评估 max(d(x)) ”会变得困难。通常的替代方案是： 在每次迭代中，在当前的候选点集上优化 d(x) ，即寻找使 f(x)' * Minv * f(x) 最大的 x 。这本身是一个非线性优化问题（通常非凸），可以使用全局优化方法（如多起点局部搜索、遗传算法等）来寻找全局极大值。如果找到的极大值超过阈值 p ，则将该点加入候选集。这种方法将“全局评估”转化为了一个“全局优化”子问题，虽然也不简单，但比在全空间密集采样要可行得多。

5. 高级话题与工程实践中的挑战

将自适应离散化算法应用于复杂的实际工程问题，会面临一系列挑战，需要更精巧的策略来处理。

5.1 高维设计空间的挑战与应对策略

当设计变量维度增加时，“维数灾难”立刻显现。连续空间变得极其庞大，即使自适应算法，也可能陷入“细不过来”的境地。

• 挑战1：敏感性函数的全局优化变得极其困难 。在高维非凸空间中寻找 d(x) 的全局极大值，计算成本高昂且不一定成功。
  • 策略 ：采用高效的全局优化启发式算法，如贝叶斯优化。贝叶斯优化特别适合目标函数评估成本高（ d(x) 计算涉及矩阵求逆，成本随参数增多而增加）的场景。它可以利用历史评估结果，智能地建议下一个最有可能找到全局最优的点进行评估。
• 挑战2：候选点集的管理 。即使自适应添加，高维下候选点集规模也可能快速增长。
  • 策略 ：引入 候选点剪枝 机制。定期移除那些权重长期为0或极低，且敏感性函数值也低的点。这类似于机器学习中的“剪枝”操作，能保持问题规模可控。
• 挑战3：初始点的质量至关重要 。在高维空间中，一个糟糕的初始离散化可能让算法在错误的方向上探索很久。
  • 策略 ：使用 空间填充设计 （如拉丁超立方设计、Sobol序列）来生成初始候选点集。这些设计能保证点在空间中的投影均匀分布，具有良好的空间探索性，为自适应算法提供一个更好的起点。

5.2 处理非线性与非凸问题

我们的例子是线性回归模型，其信息矩阵和最优性条件有良好的凸性。但对于非线性模型（如非线性回归、基于微分方程的参数估计），信息矩阵依赖于未知参数 $\theta$ 的当前估计值 $\hat{\theta}$，这导致了 局部最优设计 问题。

• 顺序设计与自适应离散化的结合 ：一种实用的方法是采用顺序（序贯）实验设计。先基于一个先验参数估计 $\theta_0$，运行自适应离散化算法得到一个初始最优设计 $\xi_0$，并执行部分实验。用获得的数据更新参数估计得到 $\theta_1$，然后基于 $\theta_1$ 重新运行自适应离散化，更新设计。如此迭代。此时，自适应离散化算法在每一轮中，都是在当前参数估计下寻找局部最优设计。
• 稳健最优设计 ：如果参数不确定性很大，可以考虑稳健最优设计准则（如贝叶斯D-最优、最小化最大方差），这些准则本身就包含了对参数空间的积分。自适应离散化算法需要同时处理设计空间和参数空间的离散化，复杂度更高，但思路相通：在设计和参数联合空间的高潜力区域进行自适应采样。

5.3 与仿真软件及分布式计算的集成

在工业界，实验设计往往与昂贵的仿真软件（如ANSYS, COMSOL, Abaqus）或物理实验绑定。

• 异步与并行评估 ：自适应算法中，评估敏感性函数 d(x) 或运行仿真获取数据 y 可能是瓶颈。需要设计算法支持异步并行。例如，在每一轮，可以同时提出多个有潜力的候选点（如 d(x) 最大的几个点），并行地进行仿真评估，然后批量更新候选集和信息矩阵。
• 代理模型（元模型）的运用 ：对于计算极其昂贵的仿真，直接调用仿真模型来评估 d(x) 是不可行的。通常的做法是，先运行一批实验点（可以是基于初始自适应设计）来构建一个快速的代理模型（如克里金模型、多项式混沌展开、神经网络），然后用这个代理模型来近似 f(x) ，从而快速计算近似的 d(x) ，指导自适应细化。当新点被加入并完成真实仿真后，再更新代理模型。这形成了一个“ 基于代理模型的自适应实验设计 ”循环，是当前复杂系统设计中的主流方法。

5.4 算法停止准则的工程化考量

理论上的停止准则是 d_max <= p + tol 。但在工程实践中，需要更灵活的准则。

• 计算预算限制 ：最常见的停止条件是达到总实验次数（仿真次数）上限。自适应算法的目标就是在预算耗尽前，找到尽可能好的设计。
• 改进量阈值 ：监控目标函数值（如 log|M| ）的增量。如果连续几次迭代，目标函数的相对提升小于某个阈值（如0.1%），则可以认为已接近平台期，停止迭代。
• 支撑点稳定性 ：观察最优设计的支撑点集合是否已经稳定。如果连续多次迭代，支撑点（权重显著大于零的点）基本不变，只是权重微调，也可以考虑停止。

6. 超越D-最优：其他设计准则的自适应实现

D-最优准则（最大化信息矩阵行列式）是最常用的，因为它具有良好的数学性质和直观解释（最小化参数估计的联合置信椭球体积）。但自适应离散化的框架同样适用于其他准则。

• A-最优准则 ：最小化参数估计的方差之和，即最小化信息矩阵逆的迹：$\text{trace}(M^{-1}(\xi))$。其敏感性函数为 $\phi_A(x, \xi) = f(x)^\top M^{-2}(\xi) f(x)$。在自适应算法中，只需将D-最优的敏感性函数 f'*Minv*f 替换为 f'*Minv^2*f （这里 Minv^2 表示 Minv*Minv ），最优性阈值也会相应变化。
• E-最优准则 ：最大化信息矩阵的最小特征值，即 $\lambda_{\min}(M(\xi))$。这增强了最不精确估计参数的精度。其敏感性函数和更新步骤更为复杂，通常涉及特征向量的计算。
• I-最优准则 ：适用于预测目的，最小化在整个设计空间上的积分预测方差。其敏感性函数涉及一个积分项。自适应实现时，需要数值近似这个积分，并在每次迭代中更新。

实现上的共通点 ：无论哪种准则，自适应离散化的核心循环不变：1) 在当前离散集上优化设计；2) 计算当前设计下该准则对应的敏感性函数；3) 在连续空间寻找敏感性函数的最大值；4) 若超过阈值，则添加该点。区别仅在于 步骤2中敏感性函数的计算公式 和 步骤4中的判断阈值 。因此，一个设计良好的自适应算法框架，应该将准则定义为可插拔的模块。

在我参与的一个材料配方优化项目中，我们最初使用了D-最优准则来筛选实验点以拟合配方-性能模型。但后来发现，我们更关心的是在配方空间某个特定区域（如满足某些成本约束的区域）的预测精度。于是我们将准则切换到了 I-最优准则 ，并修改了敏感性函数的积分区域。自适应算法依然工作良好，最终得到的设计在目标区域内的预测方差显著低于D-最优设计。这说明了算法框架的灵活性。关键在于，你必须清晰定义你的实验最终目标是什么，然后选择或构造与之匹配的设计准则。自适应离散化算法是一个强大的“执行引擎”，而准则定义了你要去的“目的地”。