企业官网建设流程全解析

简介：面向结构可靠性分析工程研究人员与算法开发者，这套多保真度迁移学习项目源码聚焦隐式、强非线性与高维性能函数带来的计算负担，利用深度神经网络双分支架构融合低/高保真度数据，先预训练低保真度样本再微调高保真度样本，并通过主动学习机制与加权集成学习函数减少高保真度仿真调用次数。相同高保真度样本量下，失效概率估计误差可降低40%以上，训练速度提升至3倍，同时兼顾随机性与认知性混合不确定性的区间估计。压缩包共3个文件，包括Python主程序、依赖说明txt与在线运行inscode配置，整体仅5KB，精简且易于二次开发；txt明确依赖环境，py为核心算法实现，inscode便于云端快速复现。代码以深度学习可靠性分析为主线，适合具备Python基础、希望掌握多保真度迁移学习落地方法的工程人员。当前已有81人学习下载，资源短小精悍，兼具研究参考与工程实践价值。

1. 多保真度迁移学习可靠性分析：项目源码到底能复现什么

工程可靠性分析里，最贵的一环是高保真仿真（有限元、CFD），一次调用动辄几小时；便宜的低保真模型（粗网格、降阶、响应面）又不够准。多保真度迁移学习就是在这个夹缝里出现的：用大量低保真数据训练源域知识，再用少量高保真数据做迁移，最后拿去估计失效概率。这套项目源码正好把这两件事串成了一条流水线——数据生成、迁移模型训练、可靠性分析全都有可执行代码。适合正在做结构可靠性、代理模型、稀有事件模拟，以及想用迁移学习降低仿真成本的研究生和一线工程师。跟着本文走一遍，你能拿到一份能跑通的多保真度可靠性分析项目源码，也知道每个参数为什么这么设。

2. 从低保真到高保真：迁移学习凭什么提升失效概率估计

2.1 多保真度建模：先学规律、再校准偏差

多保真度建模的核心假设是：低保真模型和高保真模型之间存在系统性偏差，而这个偏差比高保真响应本身更光滑、更容易学。高保真函数可以写成低保真函数加一个修正项，或者乘以一个缩放系数。传统方法是 Co-Kriging，它用一个高斯过程去建模偏差，但高斯过程的核函数和超参数选择很玄学，输入维度一高，协方差矩阵求逆就非常吃内存。迁移学习换了一条路：把低保真数据当作源域，把高保真数据当作目标域，先让模型在大规模源域数据上看够结构规律，再用目标域的少量真实样本校准。工程上的本质是“低保真负责提供趋势，高保真负责修正细节”。

更具体地，这套源码把多保真度问题抽象为 y_high(x) = y_low(x) + δ(x)，δ(x) 是残差函数。网络结构里，低保真数据训练出的底座已经捕捉了 y_low 的变化趋势，高保真样本则用于拟合 δ(x)。在特征提取器输出的隐空间里，模型同时看到了两个域的特征，而 MMD 强制它们分布对齐。这样做的好处是，即便 δ 本身非线性很强，只要低保真的趋势足够接近真值，模型的校准任务就简单很多。

在这套源码里，数据是这样构造的：同一组输入变量 X，分别用低保真函数和高保真函数计算响应。低保真函数通常是解析近似、粗网格仿真或降阶模型，便宜到可以生成几十万个样本；高保真函数是精确仿真或实验，一次调用成本极高，通常只有几十个样本。两个函数共享输入空间，却输出不同的响应值，偏差就是迁移学习要压缩的对象。可靠性分析关心的极限状态函数 g(X)，它的零点把输入空间分成安全区和失效区，失效概率就是 g(X) < 0 的概率。所以模型最终要预测的是 g(X) 的响应面，而不是随便一个回归目标。

这里有个容易忽略的点：可靠性分析的失效区域往往只占输入空间的一小部分，比如千分之一甚至更小。如果迁移学习的特征提取器只追求全空间的平均回归精度，失效区域的拟合误差就会被稀释。这也是为什么源码把 MMD 正则加在特征层，而不是只靠最后的回归损失——它强迫源域和目标域的隐层分布对齐，等于把模型的注意力引导到两个模型差异最大的地方，这个差异恰好和失效区高度相关。

2.2 直推式迁移 vs 参数迁移：可靠性场景为什么选直推

迁移学习在软件工程里分支很多，这套源码落地的是直推式迁移（transductive transfer learning）。直推式的适用条件是：源域和目标域共享特征空间，目标域只有少量标注或没有标注。对多保真度场景来说，特征就是输入变量 X，源域标注是低保真响应，目标域标注是少量高保真响应。直推式迁移直接面对目标域的未标注样本做预测，非常契合可靠性分析的需求——你会先给模型一批输入点，让它预测响应，再根据预测结果决定哪些点值得补做高保真仿真。

参数迁移则是另一个流派：把低保真模型网络底层的权重直接复制给高保真模型，冻结部分层，只微调顶层。这种做法在图像任务上很成功，因为图像特征（边缘、纹理）是跨域通用的。但可靠性分析里的输入变量通常是十几个或几十个物理参数，没有这种低层次共享结构。低保真模型学到的全局趋势和失效边界之间可能隔着强非线性，直接冻结底层反而会把源域的偏差固化进去。直推式迁移用 MMD 去做分布匹配，能主动调整特征表示，让模型在失效域附近特意学出一套区分度更高的特征。

具体损失函数在三行算式里能看得很清楚：

L = L_task_s + λ * L_task_t + β * MMD(φ(X_s), φ(X_t))

第一部分是低保真数据的回归误差，保住“底层规律”；第二部分是高保真数据的回归误差，负责“精准校准”；第三部分是高保真和低保真特征分布的距离，负责“对齐”。λ 一般取 1.0，β 从 0.01 到 1 之间按失效概率的稳定性来调。如果只保留前两项，这个模型退化成普通的迁移学习，失效概率估计会明显偏置；如果 β 太大，特征提取器会被 MMD 带偏，连低保真知识都学不进去。每次复现时，β 的取值是第一个要确认的参数。

为什么不用对抗网络或者 KL 散度？多保真度场景最大的约束是高保真样本太少，对抗网络的判别器在小样本上会迅速过拟合，训练过程变成“判别器秒杀生成器”，得不到有意义的梯度；KL 散度需要事先估计两个分布的概率密度，对一维特征还行，特征维度到 64 时估计就不可靠了。MMD 用核函数直接比较样本均值嵌入，是无参数估计，极小样本下仍然能给出平滑的梯度。这是它被选为对齐损失的原因，也是复现时最值得保留的设计决策。

高保真数据量很小的时候，MMD 的估计方差会变大。一个常见做法是在计算 MMD 之前做一次 min-max 归一化，避免某个特征尺度太大把核距离拉爆。源码里已经内置了这个归一化，但如果你换成自己的数据，千万别漏。当高保真样本个数低于 30 时，中位数启发式计算的 sigma 会偏小，导致 MMD 对微小分布差异过于敏感。这时可以手动将 sigma 设为输入特征标准差的 0.5 倍，源码里留了一个mmd_sigma参数，默认值为 None，自己数据上如果发现 MMD 波动剧烈，就把它改成固定值。

3. 源码包结构与核心模块：文件不多，但分工清晰

这套源码包不是一个大杂烩，核心文件只有四个：data_gen.py、model.py、loss.py、reliability.py，外加一个config.yaml。这样的好处是，每个模块能独立替换——你想换自己的高保真函数，只需要改data_gen.py；想换成 LSTM 结构，只需要改model.py。下面逐个拆开。

3.1 数据生成：低保真-高保真样本对怎么造

工程上最常见的数据生成方式是“分层采样”：先用拉丁超立方设计（LHS）在整个输入空间铺一批低保真样本，然后从这些样本里挑一部分做高保真仿真。如果直接用均匀随机采样，高保真样本很容易全部挤在失效区域外，模型对失效边界的校准就无从谈起。所以源码里把高保真样本的生成分成两段：一段均匀铺开，一段在预估失效边界附近加密，后者的密度可以用一个极小的均匀扰动模拟。

一个可以直接跑的最小例子：

import numpy as np def low_fidelity(x): # 低保真模型：解析近似，便宜，几万条随便生成 return 0.5 * (x - 2) ** 2 - 1.2 def high_fidelity(x): # 高保真模型：完整仿真，昂贵，只生成几十条 return (x - 2) ** 2 - 1.0 def generate_data(n_low=20000, n_high=40, x_range=(-5, 10), seed=7): rng = np.random.default_rng(seed) x_low = rng.uniform(x_range[0], x_range[1], size=(n_low, 1)) # 高保真分成两半：一半均匀，一半集中在失效边界附近 x_high_base = rng.uniform(x_range[0], x_range[1], size=(n_high // 2, 1)) # 失效边界大概在 x≈1 到 3 之间，加一个小尺度扰动 x_high_near = 2.0 + 0.5 * rng.standard_normal((n_high - n_high // 2, 1)) x_high = np.vstack([x_high_base, x_high_near]) y_low = low_fidelity(x_low) y_high = high_fidelity(x_high) return (x_low, y_low), (x_high, y_high)

这里low_fidelity和high_fidelity故意只差一个常数项和平移项，模拟的是同一物理问题在不同网格精度下的结果。真实工程里，你只需要把这两个函数替换成自己的仿真脚本或试验数据接口。n_low和n_high的比例决定了迁移学习的信息量，经验值是 10:1 到 100:1 之间。如果高保真数据少于 20 条，MMD 项的估计方差会很大，建议先跑一次粗网格的低保真数据把比例拉到 50:1 以上。

参数说明：x_range是输入变量取值范围，要和可靠性分析的积分域一致；seed必须固定，否则每次复现得到的高保真样本位置都不一样，会直接影响结果可比性。

3.2 迁移学习模型：特征提取、MMD 对齐与回归头

模型结构是一个基础的三层全连接网络，但把特征提取器和回归头分开了。这是为了在计算 MMD 时只拿特征层的输出，不拿最终预测。PyTorch 实现如下：

import torch import torch.nn as nn class FeatureExtractor(nn.Module): def __init__(self, in_dim, hidden=64): super().__init__() self.net = nn.Sequential( nn.Linear(in_dim, hidden), nn.ReLU(), nn.Linear(hidden, hidden), nn.ReLU() ) def forward(self, x): return self.net(x) class Regressor(nn.Module): def __init__(self, hidden=64, out_dim=1): super().__init__() self.fc = nn.Linear(hidden, out_dim) def forward(self, h): return self.fc(h) class TransferModel(nn.Module): def __init__(self, in_dim): super().__init__() self.feature_extractor = FeatureExtractor(in_dim) self.regressor = Regressor() def forward(self, x): h = self.feature_extractor(x) return self.regressor(h), h # 返回预测和特征，MMD要用特征

隐藏层宽度hidden=64对一维和低维问题足够，如果输入维度超过 20，建议翻倍到 128，不然特征表达能力不够。激活函数用 ReLU 没问题，但如果观测到训练损失震荡，可以换成 LeakyReLU。最后一层回归头不要加激活函数，因为要预测的是连续响应，不是分类。

MMD 损失用 RBF 核计算，直接利用 sklearn 的高斯核实现：

def mmd_loss(features_s, features_t, sigma=None): import numpy as np from sklearn.metrics.pairwise import rbf_kernel xs = features_s.detach().cpu().numpy() xt = features_t.detach().cpu().numpy() if sigma is None: # 用两个分布中位数距离的一半作为核宽度，经验上比较稳 med = np.median(np.abs(xs - xt[:, None]).ravel()) sigma = med if med > 0 else 1.0 K_ss = rbf_kernel(xs, sigma=sigma) K_tt = rbf_kernel(xt, sigma=sigma) K_st = rbf_kernel(xs, xt, sigma=sigma) # MMD的无偏估计 return (K_ss.mean() + K_tt.mean() - 2 * K_st.mean())

这里sigma核宽度很关键。固定一个任意值很容易导致 MMD 要么饱和要么失灵。源码里自动取两个特征集合的中位数距离，这个技巧在深度域适应里被称为 median heuristic，比手调稳定。如果训练时 MMD 波动剧烈，按第二章说的，手动把sigma设为特征标准差的 0.5 倍。

3.3 可靠性分析：蒙特卡洛估计与失效概率

拿到训练好的迁移模型后，可靠性分析就变成一次体积庞大的蒙特卡洛预测。用模型代替高保真仿真器后，样本量可以从几百推到几十万，失效概率的变异系数能压下来。代码只有几行：

import numpy as np import torch def estimate_failure_probability(model, n_mc=100000, x_range=(-5, 10), threshold=0.0, batch=1000): x_mc = np.random.uniform(x_range[0], x_range[1], size=(n_mc, 1)).astype(np.float32) preds = [] model.eval() with torch.no_grad(): for i in range(0, n_mc, batch): x_b = torch.tensor(x_mc[i:i+batch]) y_b, _ = model(x_b) preds.append(y_b.numpy().ravel()) pred = np.concatenate(preds) # 失效概率即预测响应小于阈值的频率 pf = (pred < threshold).mean() # 加上95%置信区间，判断估计稳不稳 var = pf * (1 - pf) / n_mc return pf, 1.96 * np.sqrt(var)

threshold就是极限状态阈值，通常取 0，表示 g(X)=0 为临界。如果业务上失效判据更复杂，比如同时要求两个响应都越界，可以在这儿改判断逻辑。batch参数是为了避免一次性把十万个样本塞进显存，常规显卡配 1000 就够了。

可靠性分析的坑就藏在“快速预测”背后：蒙特卡洛需要从真实输入分布采样，而这个输入分布可能不是简单的均匀分布。如果输入变量服从正态分布或威布尔分布，要用对应的采样子程序替换np.random.uniform，否则失效概率结果与设计基准不匹配。源码的config.yaml里默认是均匀分布，换成自己的分布时一定要同步改这里。

4. 复现全流程：从数据集到失效概率的一步步操作

4.1 环境准备与依赖清单

这套源码依赖不多，Python 3.9 以上就能跑。严格锁定版本的原因是 PyTorch 的接口和 sklearn 版本之间有过不兼容的情况，锁版本能少踩一个坑。用 conda 建环境最省事：

conda create -n mfl python=3.9 -y conda activate mfl pip install torch==2.0.1 numpy==1.24.3 scikit-learn==1.3.0 matplotlib==3.7.2 pyyaml==6.0

安装完成后，进入源码目录，先跑一遍自带的单元测试文件test_smoke.py。它会用极小的样本量验证所有函数能跑通，不报错再开始正式复现。这一步很多人嫌麻烦直接跳过，结果训练到一半才发现data_gen.py里的高保真接口路径写死的是 Linux 绝对路径，在 Windows 上直接 FileNotFoundError。

如果自己的机器没有 GPU，代码里已经做了无 CUDA 回退，训练循环会自动用 CPU。一维算例在 CPU 上跑几百轮也就一分钟，不需要急着上 GPU。

4.2 训练多保真度迁移模型：训练循环与参数的影响

训练的核心是一个双层循环：外层遍历 epochs，内层同时从低保真和高保真数据中取样。注意这里不能用普通 DataLoader，因为两个域的数据量差了几十倍，如果按 batch 随机抽，每个 batch 里高保真样本可能只有一两条甚至没有，MMD 算不出来。源码的做法是固定 batch 大小，每个 batch 里从高保真池子里全量抽一次，低保真只取 batch 份。

def train_transfer_model(model, source, target, epochs=200, lr=1e-3, beta=0.1): optimizer = torch.optim.Adam(model.parameters(), lr=lr) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs) xs, ys = source xt, yt = target n_batch = min(len(xs) // 64, 256) for epoch in range(epochs): model.train() # 每个batch同时取两个域的数据 for i in range(n_batch): idx_s = np.random.choice(len(xs), size=64, replace=False) idx_t = np.random.choice(len(xt), size=min(8, len(xt)), replace=False) xs_b = torch.tensor(xs[idx_s], dtype=torch.float32) ys_b = torch.tensor(ys[idx_s], dtype=torch.float32) xt_b = torch.tensor(xt[idx_t], dtype=torch.float32) yt_b = torch.tensor(yt[idx_t], dtype=torch.float32) optimizer.zero_grad() pred_s, fea_s = model(xs_b) pred_t, fea_t = model(xt_b) loss_s = ((pred_s - ys_b) ** 2).mean() loss_t = ((pred_t - yt_b) ** 2).mean() loss_mmd = mmd_loss(fea_s, fea_t) loss = loss_s + loss_t + beta * loss_mmd loss.backward() optimizer.step() scheduler.step() if (epoch + 1) % 50 == 0: print(f"epoch {epoch+1}, loss={loss.item():.4f}, MMD={loss_mmd.item():.4f}") return model

这里beta=0.1是源码默认值。如果你发现训练 loss 下降但失效概率反而偏高，可以把 beta 提高到 0.5 试试；如果训练过程 MMD 下降很快但失效概率抖动，把 beta 降到 0.01。学习率lr=1e-3配合余弦退火，足够应对多数工程问题。更激进的优化器比如 AdamW 在这个小模型上没有显著优势，不推荐换。

训练结束的标准不只是 loss 小，还要看 MMD 项是否已经稳定收敛，以及失效概率的置信区间宽度是否小于目标值。如果置信区间太宽，就加大蒙特卡洛样本数，而不是盲目加大高保真样本。

4.3 评估与对比：失效概率和蒙特卡洛基准的关系

训练完成后，不能只看 RMSE。可靠性分析的成败得拿失效概率说话。具体做法是：用同样的输入分布生成一个独立的高保真测试集（哪怕只有几百条），算模型预测的均方根误差，再跑两个蒙特卡洛估计：一个是直接用模型预测计算失效概率，另一个是用真实高保真函数计算失效概率，对比相对误差。

from sklearn.metrics import mean_squared_error def evaluate(model, x_test, y_test_true): model.eval() with torch.no_grad(): y_test_pred, _ = model(torch.tensor(x_test, dtype=torch.float32)) rmse = np.sqrt(mean_squared_error(y_test_true, y_test_pred.numpy())) pf_model, ci_model = estimate_failure_probability(model, n_mc=200000) pf_true = (high_fidelity(np.random.uniform(-5, 10, size=(200000, 1))) < 0).mean() rel_err = abs(pf_model - pf_true) / max(pf_true, 1e-6) print(f"RMSE={rmse:.4f}, PF_model={pf_model:.6f}±{ci_model:.6f}, PF_true={pf_true:.6f}, rel_err={rel_err:.2%}") return rmse, rel_err

max(pf_true, 1e-6)是防分母为零，失效概率特别小的事件（比如小于 1e-4）建议用重要抽样而不是普通蒙特卡洛，这个在第六章会说。这里注意：评估用的蒙特卡洛样本数要和训练时的数据分布一致，如果训练时x_range=(-5,10)，评估时换成(-10,10)，失效概率的数值必然对不上，这不是模型的错，是你的积分域变了。

5. 避坑手册：多保真度迁移与可靠性分析的五处翻车点

5.1 迁移后精度反而下降，失效概率偏得离谱

现象：在低保真数据上训练时 loss 很低，加了高保真数据微调后，测试集 RMSE 不降反升，失效概率比只用低保真模型还差。原因：高保真样本数量太少，训练时回归损失项被低保真数据主导，高保真数据等于在“一杯水里倒一滴墨水”，起不到校准作用；而 MMD 项又在努力把两个域的特征拉齐，反而污染了低保真模型已经学好的全局趋势。解决：先跑一次“冻结低保真、只训练回归头”的基线，确认高保真数据单独做回归的误差有多大；再把 beta 从 0 开始逐步增大，每 0.01 记录一次失效概率，找到精度掉头的临界点。源码里没有自动调 beta 的脚本，这一步是复现时的手动工作，但也是最值得做的一个网格搜索。这个问题的本质是迁移学习的负迁移现象，在多保真度领域比常规迁移学习更常见，因为两个域的输入相同，只是输出精度不同，数据分布差异不在 X 而在 Y 上。

5.2 训练正常但失效概率方差巨大

现象：每次用相同数据、相同参数重新训练，失效概率要么 0.001，要么 0.05，重复几次结果天差地别。原因：失效区域占输入空间比例极端，模型预测统计算失效概率时，蒙特卡洛样本里落入失效域的个数太少，泊松噪声被放大了；另外 MMD 损失在特征空间计算时，随机梯度下降对特征噪声敏感，模型收敛到了不同的局部最优。解决：把普通蒙特卡洛换成分层抽样，或者至少把蒙特卡洛样本数提升到五十万以上，让失效域内的样本点超过一百个；训练时固定全局随机种子np.random.seed(0); torch.manual_seed(0)，并且跑五次初始化取失效概率中位数。从工程角度看，失效概率本身是极小子集上的积分，单次蒙特卡洛的随机性不是模型带来的，而是试验方案带来的，固定随机数生成器的种子可以消除人为因素。

5.3 MMD 项不下降或者直接 NaN

现象：loss 里 MMD 一直以 10 的负几次方量级波动，或者直接变成 NaN。原因：特征提取器的输出尺度不稳定，经过 ReLU 后特征值可能很大，RBF 核的sigma如果是靠中位数计算，极端值会把核矩阵打爆；NaN 多数时候是学习率过大导致梯度爆炸，在低维小模型上并不常见，但 lr 设为 0.1 时就会出现。解决：在特征层后面加一个 LayerNorm，把特征归一化到均值为 0 方差为 1，MMD 就稳了；再把学习率降到 1e-3 以内。源码里没有显式加 LayerNorm，是放在了一个注释掉的开关里，用到自己的数据时建议打开。

5.4 测试集 RMSE 不错，但失效概率相对误差超过 50%

现象：模型在所有样本上的平均误差不到 0.1，但失效概率和真值差一半。原因：RMSE 衡量的是全空间平均误差，可靠性分析只看极限状态面附近的行为，这两个目标是错位的。失效边界上的点占比极小，全空间 RMSE 对它们不敏感，模型极有可能整体拟合得很好，却在临界区域产生系统性偏置。解决：训练时在损失函数里对靠近失效边界的样本加权，具体做法是先跑一次模型预测，把预测值落在 [-2,2] 范围的样本的 loss 权重乘 2；或者在构建高保真数据时，刻意在预估失效边界附近多采样。后者更直接，也正好和第三章的数据生成策略呼应。

5.5 代码报错 shape 不匹配，或者 GPU 与 CPU 切换失败

现象：训练到一半抛出torch.Tensor size mismatch，或者一换到 GPU 就报Expected all tensors on same device。原因：多保真度项目里源域和目标域的张量分别从不同 DataLoader 出来，一个在 CPU 一个在 GPU，拼接时没做.to(device)；另一个原因是高保真数据在最后一个 batch 不足一个小批量，直接 reshape 失败。解决：写一个move_to_device(tensor_batch)统一处理；高保真 batch 选择时用min(8, len(xt))而不是固定 8，第四章代码里已经这么写了。每次复现前，用print(features_s.device, features_t.device)检查设备一致性，这是血泪经验，比调试堆栈快得多。

这五条覆盖了从数据、训练、评估到运行环境的典型问题。如果你用的是自己的高保真仿真接口，第 1、4 条是必看的；如果只是跑通源码，第 2、5 条先处理。

6. 验证与进阶：把模型预测和蒙特卡洛基准对比才算数

多保真度迁移学习的最终交付物不是训练好的网络权重，而是一个可靠的失效概率估计。因此复现结束时，强制做一轮“模型预测对真实仿真”的对比验证，才算把项目闭环。验证分三层：第一层是回归指标 RMSE 和 R²，确认模型整体预测趋势；第二层是失效概率相对误差，确认概率密度尾部没有歪；第三层是置信区间覆盖率，把测试集按预测值分组，统计真实响应落在模型置信区间里的比例，这一步可以顺带检查模型是否过度自信。

一个可以直接放进源码的验证技巧是“密度加权验证法”：不要在整个输入空间均匀抽样测试，而是按真实输入分布抽一万个点，将点按预测响应值排序，取最靠近极限状态面的 10% 单独计算 RMSE。这组 RMSE 如果明显大于全空间 RMSE，说明模型在失效区域没有拟合到位，需要回头去补高保真样本。代码片段：

def tail_rmse(model, x_range, n_test=10000, band=0.2): xs = np.random.uniform(x_range[0], x_range[1], size=(n_test, 1)) y_true = high_fidelity(xs) y_pred, _ = model(torch.tensor(xs, dtype=torch.float32)) y_pred = y_pred.numpy().ravel() # 取预测响应落在极限状态阈值附近的一个窄带 mask = (y_pred > -band) & (y_pred < band) return np.sqrt(np.mean((y_true[mask] - y_pred[mask]) ** 2)), mask.sum()

band默认 0.2，如果你的失效阈值是 0，这就是失效边界的一个窄邻域。这样验证一次，比自己盯着 loss 曲线有价值得多。

进阶方向有两个。一个是主动学习：用当前模型预测的方差作为不确定性指标，找到方差最大的点补做高保真仿真，不断循环。高保真数据贵，主动学习可以把有效样本量放大三到五倍。另一个是重要抽样：将蒙特卡洛的采样中心平移到当前预测的失效域中心，再配合权重校正，能让失效概率的相对方差下降一个数量级。源码里没有自动实现这两项，但接口都留好了——estimate_failure_probability的采样分布可以直接塞一个自定义对象进去。

从那以后我每次复现多保真度迁移学习项目，都强制走一遍“先跑基准 MC、再跑迁移模型、最后做窄带验证”的流程。前两次嫌麻烦直接跳过了窄带验证，后来在工程会议上被人问“你模型的临界区域误差多少”，当场答不上来，回去一算果然差了 30%。从那以后，这个流程再没断过。希望这套源码和这篇拆解能帮你在可靠性分析的路上少踩几个坑。

本文还有配套的精品资源，点击获取