基于MATLAB的子集模拟算法及其优化

一、MATLAB标准子集模拟实现

1.1 主程序框架

matlab 复制代码

% subset_simulation_main.m
% 子集模拟主程序

clear all; close all; clc;

% 设置参数
N = 1000;          % 每层样本数
p0 = 0.1;          % 条件概率
Nc = round(p0*N);  % 条件样本数
dim = 2;           % 问题维度

% 定义极限状态函数（示例：双变量非线性函数）
limit_state_func = @(x) 5 - 0.5*(x(1)-1).^2 - (x(2)+0.5).^2;

% 运行子集模拟
[Pf, cov, samples, levels] = subsetSimulation(limit_state_func, dim, N, p0);

% 显示结果
fprintf('失效概率: %e\n', Pf);
fprintf('变异系数: %f\n', cov);
fprintf('模拟层数: %d\n', length(levels));

1.2 标准子集模拟函数

matlab 复制代码

% subsetSimulation.m
% 标准子集模拟实现

function [Pf, cov, all_samples, levels] = subsetSimulation(g, dim, N, p0)
    % 输入参数:
    %   g - 极限状态函数句柄 (g(X) <= 0 表示失效)
    %   dim - 随机变量维度
    %   N - 每层样本数
    %   p0 - 条件概率
    % 输出参数:
    %   Pf - 失效概率估计
    %   cov - 变异系数
    %   all_samples - 所有样本
    %   levels - 各层阈值
    
    % 初始化
    Nc = round(p0*N);           % 条件样本数
    samples = randn(N, dim);    % 第0层样本
    g_values = zeros(N, 1);     % 极限状态函数值
    
    % 计算第0层
    for i = 1:N
        g_values(i) = g(samples(i,:)');
    end
    
    % 排序并确定阈值
    [sorted_g, idx] = sort(g_values);
    b = sorted_g(Nc);           % 第一层阈值
    
    % 存储结果
    all_samples = {samples};
    levels = b;
    Pf_conditional = 1.0;
    layer = 0;
    
    % 子集模拟循环
    while b > 0
        layer = layer + 1;
        fprintf('第%d层模拟, 阈值: %.4f\n', layer, b);
        
        % 选择种子样本
        seed_samples = samples(idx(1:Nc), :);
        
        % 使用MCMC生成新样本
        [new_samples, new_g_values] = mcmc_sampling(g, seed_samples, b, N);
        
        % 更新样本和函数值
        samples = new_samples;
        g_values = new_g_values;
        
        % 排序并确定新阈值
        [sorted_g, idx] = sort(g_values);
        if Nc < N
            b = sorted_g(Nc);
        else
            b = sorted_g(end);
        end
        
        % 存储结果
        all_samples{end+1} = samples;
        levels(end+1) = b;
        Pf_conditional = Pf_conditional * p0;
    end
    
    % 计算最终失效概率
    n_fail = sum(g_values <= 0);
    Pf = Pf_conditional * (n_fail / N);
    
    % 计算变异系数（简化估计）
    cov = sqrt((1-p0)/(N*p0) + (layer+1)*(1-p0)/(N*p0^2));
end

1.3 MCMC抽样函数

matlab 复制代码

% mcmc_sampling.m
% Metropolis-Hastings MCMC抽样

function [samples, g_values] = mcmc_sampling(g, seeds, threshold, N_total)
    % 输入参数:
    %   g - 极限状态函数
    %   seeds - 种子样本
    %   threshold - 当前层阈值
    %   N_total - 需要生成的总样本数
    % 输出参数:
    %   samples - 新样本
    %   g_values - 对应的函数值
    
    [Nc, dim] = size(seeds);
    samples = zeros(N_total, dim);
    g_values = zeros(N_total, 1);
    
    % 初始样本为种子
    samples(1:Nc, :) = seeds;
    for i = 1:Nc
        g_values(i) = g(seeds(i,:)');
    end
    
    % MCMC参数
    sigma = 1.0;          % 建议分布标准差
    acceptance_rate = 0;
    
    % 生成剩余样本
    for i = Nc+1:N_total
        % 随机选择一个种子作为起点
        idx = randi(Nc);
        current = seeds(idx, :);
        
        accepted = false;
        attempts = 0;
        max_attempts = 100;
        
        while ~accepted && attempts < max_attempts
            % 生成候选样本
            candidate = current + sigma * randn(1, dim);
            
            % 计算函数值
            g_candidate = g(candidate');
            
            % 接受准则：必须在当前失效域内
            if g_candidate <= threshold
                samples(i, :) = candidate;
                g_values(i) = g_candidate;
                
                % 以一定概率更新种子
                if rand() < 0.1
                    seeds(idx, :) = candidate;
                end
                
                accepted = true;
                acceptance_rate = acceptance_rate + 1;
            end
            
            attempts = attempts + 1;
        end
        
        % 如果未接受，使用最后一个种子
        if ~accepted
            samples(i, :) = current;
            g_values(i) = g(current');
        end
    end
    
    acceptance_rate = acceptance_rate / (N_total - Nc);
    fprintf('MCMC接受率: %.2f%%\n', acceptance_rate*100);
end

二、子集模拟优化算法

2.1 自适应MCMC优化

matlab 复制代码

% adaptive_subset_simulation.m
% 自适应子集模拟

function [Pf, cov] = adaptiveSubsetSimulation(g, dim, N, p0)
    % 自适应调整MCMC步长以提高效率
    
    Nc = round(p0*N);
    samples = randn(N, dim);
    g_values = zeros(N, 1);
    
    % 计算初始样本
    for i = 1:N
        g_values(i) = g(samples(i,:)');
    end
    
    [sorted_g, idx] = sort(g_values);
    b = sorted_g(Nc);
    
    Pf_conditional = 1.0;
    layer = 0;
    
    while b > 0
        layer = layer + 1;
        
        % 选择种子
        seeds = samples(idx(1:Nc), :);
        
        % 自适应MCMC参数
        target_acceptance = 0.3;  % 目标接受率
        sigma = adaptiveSigma(seeds, g, b, target_acceptance);
        
        fprintf('第%d层 - 阈值: %.4f, 自适应sigma: %.3f\n', layer, b, sigma);
        
        % 使用自适应MCMC
        [samples, g_values] = adaptive_mcmc(g, seeds, b, N, sigma);
        
        % 更新阈值
        [sorted_g, idx] = sort(g_values);
        b = sorted_g(Nc);
        
        Pf_conditional = Pf_conditional * p0;
    end
    
    n_fail = sum(g_values <= 0);
    Pf = Pf_conditional * (n_fail / N);
    cov = sqrt((1-p0)/(N*p0));
end

function sigma = adaptiveSigma(seeds, g, threshold, target_rate)
    % 自适应调整sigma以达到目标接受率
    
    sigma = 1.0;
    [Nc, dim] = size(seeds);
    
    % 测试不同的sigma值
    test_sigmas = [0.1, 0.5, 1.0, 2.0, 3.0];
    accept_rates = zeros(size(test_sigmas));
    
    for s = 1:length(test_sigmas)
        sigma_test = test_sigmas(s);
        accepted = 0;
        total = 100;
        
        for i = 1:total
            idx = randi(Nc);
            current = seeds(idx, :);
            candidate = current + sigma_test * randn(1, dim);
            
            if g(candidate') <= threshold
                accepted = accepted + 1;
            end
        end
        
        accept_rates(s) = accepted / total;
    end
    
    % 选择最接近目标接受率的sigma
    [~, idx] = min(abs(accept_rates - target_rate));
    sigma = test_sigmas(idx);
end

2.2 基于重要抽样的混合算法

matlab 复制代码

% hybrid_subset_simulation.m
% 混合子集模拟（结合重要抽样）

function [Pf, cov] = hybridSubsetSimulation(g, dim, N, p0)
    % 结合重要抽样提高效率
    
    Nc = round(p0*N);
    samples = randn(N, dim);
    g_values = zeros(N, 1);
    
    % 第一层：标准抽样
    for i = 1:N
        g_values(i) = g(samples(i,:)');
    end
    
    [sorted_g, idx] = sort(g_values);
    thresholds = sorted_g(Nc);
    Pf_conditional = 1.0;
    
    % 后续层：混合抽样
    while thresholds(end) > 0
        seeds = samples(idx(1:Nc), :);
        
        % 估计重要抽样密度
        [mu, Sigma] = estimateImportanceDensity(seeds);
        
        % 混合抽样：一半MCMC，一半重要抽样
        N_mcmc = round(N/2);
        N_is = N - N_mcmc;
        
        % MCMC抽样
        [samples_mcmc, g_mcmc] = mcmc_sampling(g, seeds, thresholds(end), N_mcmc);
        
        % 重要抽样
        [samples_is, g_is, weights] = importanceSampling(g, mu, Sigma, N_is, thresholds(end));
        
        % 合并样本
        samples = [samples_mcmc; samples_is];
        g_values = [g_mcmc; g_is];
        
        % 加权排序
        weighted_values = g_values .* weights;
        [sorted_g, idx] = sort(weighted_values);
        
        thresholds(end+1) = sorted_g(Nc);
        Pf_conditional = Pf_conditional * p0;
    end
    
    % 计算失效概率（考虑权重）
    fail_idx = g_values <= 0;
    Pf = Pf_conditional * sum(weights(fail_idx)) / sum(weights);
    cov = 0.1;  % 简化变异系数计算
end

function [mu, Sigma] = estimateImportanceDensity(samples)
    % 估计重要抽样密度参数
    mu = mean(samples);
    Sigma = cov(samples);
    
    % 添加正则化防止奇异
    Sigma = Sigma + eye(size(Sigma)) * 0.01;
end

function [samples, g_values, weights] = importanceSampling(g, mu, Sigma, N, threshold)
    % 重要抽样
    dim = length(mu);
    
    % 从建议分布抽样
    samples = mvnrnd(mu, Sigma, N);
    g_values = zeros(N, 1);
    weights = zeros(N, 1);
    
    % 计算权重
    for i = 1:N
        g_values(i) = g(samples(i,:)');
        if g_values(i) <= threshold
            % 权重 = 目标分布/建议分布
            % 目标分布为标准正态，建议分布为N(mu, Sigma)
            target_pdf = mvnpdf(samples(i,:), zeros(1,dim), eye(dim));
            proposal_pdf = mvnpdf(samples(i,:), mu, Sigma);
            weights(i) = target_pdf / proposal_pdf;
        else
            weights(i) = 0;
        end
    end
end

2.3 并行计算优化

matlab 复制代码

% parallel_subset_simulation.m
% 并行子集模拟

function [Pf, cov] = parallelSubsetSimulation(g, dim, N, p0, num_workers)
    % 使用并行计算加速
    
    % 设置并行池
    if isempty(gcp('nocreate'))
        parpool(num_workers);
    end
    
    Nc = round(p0*N);
    samples = randn(N, dim);
    
    % 并行计算极限状态函数
    g_values = zeros(N, 1);
    parfor i = 1:N
        g_values(i) = g(samples(i,:)');
    end
    
    [sorted_g, idx] = sort(g_values);
    b = sorted_g(Nc);
    Pf_conditional = 1.0;
    
    while b > 0
        seeds = samples(idx(1:Nc), :);
        
        % 并行MCMC抽样
        samples = parallel_mcmc(g, seeds, b, N, num_workers);
        
        % 并行计算函数值
        g_values = zeros(N, 1);
        parfor i = 1:N
            g_values(i) = g(samples(i,:)');
        end
        
        [sorted_g, idx] = sort(g_values);
        b = sorted_g(Nc);
        Pf_conditional = Pf_conditional * p0;
    end
    
    n_fail = sum(g_values <= 0);
    Pf = Pf_conditional * (n_fail / N);
    cov = sqrt((1-p0)/(N*p0));
end

function samples = parallel_mcmc(g, seeds, threshold, N_total, num_workers)
    % 并行MCMC抽样
    
    [Nc, dim] = size(seeds);
    samples_per_worker = ceil(N_total / num_workers);
    
    % 分配任务
    seeds_cell = cell(num_workers, 1);
    for w = 1:num_workers
        seeds_cell{w} = seeds;
    end
    
    % 并行执行
    spmd
        worker_samples = mcmc_sampling_worker(g, seeds_cell{labindex}, ...
            threshold, samples_per_worker);
    end
    
    % 收集结果
    samples = [];
    for w = 1:num_workers
        samples = [samples; worker_samples{w}];
    end
    
    % 截断到所需数量
    samples = samples(1:N_total, :);
end

三、系统可靠性分析示例

3.1 串联系统可靠性

matlab 复制代码

% series_system_reliability.m
% 串联系统可靠性分析

function Pf_series = seriesSystemReliability(dim, N, p0)
    % 定义多个极限状态函数（串联系统）
    g1 = @(x) 3 - norm(x - [0.5, 0.5], 2);
    g2 = @(x) 2 - abs(x(1) - x(2));
    g3 = @(x) 4 - sum(abs(x));
    
    % 串联系统：所有组件都失效
    g_system = @(x) max([g1(x), g2(x), g3(x)]);
    
    % 运行子集模拟
    [Pf_series, cov] = subsetSimulation(g_system, dim, N, p0);
    
    fprintf('串联系统失效概率: %e\n', Pf_series);
    fprintf('变异系数: %.4f\n', cov);
    
    % 敏感性分析
    sensitivityAnalysis(g_system, dim);
end

3.2 并联系统可靠性

matlab 复制代码

% parallel_system_reliability.m
% 并联系统可靠性分析

function Pf_parallel = parallelSystemReliability(dim, N, p0)
    % 并联系统：任一组件失效
    
    g1 = @(x) 3 - norm(x, 2);
    g2 = @(x) 2 - x(1)^2 - 0.5*x(2)^2;
    g3 = @(x) 1 - 0.8*x(1) - 0.6*x(2);
    
    % 并联系统：最小函数值决定失效
    g_system = @(x) min([g1(x), g2(x), g3(x)]);
    
    [Pf_parallel, cov] = subsetSimulation(g_system, dim, N, p0);
    
    fprintf('并联系统失效概率: %e\n', Pf_parallel);
    fprintf('变异系数: %.4f\n', cov);
end

3.3 敏感性分析

matlab 复制代码

% sensitivityAnalysis.m
% 可靠性敏感性分析

function sensitivityAnalysis(g, dim)
    % 通过扰动分析计算敏感性
    
    N_samples = 10000;
    samples = randn(N_samples, dim);
    
    % 计算基础失效概率
    g_values = zeros(N_samples, 1);
    for i = 1:N_samples
        g_values(i) = g(samples(i,:)');
    end
    Pf_base = mean(g_values <= 0);
    
    % 变量敏感性
    sensitivities = zeros(1, dim);
    
    for d = 1:dim
        % 扰动第d个变量
        perturbed_samples = samples;
        perturbed_samples(:, d) = perturbed_samples(:, d) * 1.1;  % 10%增加
        
        % 计算扰动后的失效概率
        g_values_perturbed = zeros(N_samples, 1);
        for i = 1:N_samples
            g_values_perturbed(i) = g(perturbed_samples(i,:)');
        end
        Pf_perturbed = mean(g_values_perturbed <= 0);
        
        % 计算敏感性
        sensitivities(d) = (Pf_perturbed - Pf_base) / (0.1 * Pf_base);
    end
    
    % 显示结果
    fprintf('\n敏感性分析:\n');
    for d = 1:dim
        fprintf('变量 %d 敏感性: %.4f\n', d, sensitivities(d));
    end
    
    % 绘制敏感性图
    figure;
    bar(sensitivities);
    xlabel('变量索引');
    ylabel('敏感性系数');
    title('可靠性敏感性分析');
    grid on;
end

四、性能评估与比较

matlab 复制代码

% performance_comparison.m
% 不同算法性能比较

function performanceComparison()
    % 测试函数
    g = @(x) 5 - norm(x, 2);  % 简单球面失效域
    
    dim = 5;
    N = 2000;
    p0 = 0.1;
    
    % 测试不同算法
    algorithms = {'标准子集模拟', '自适应子集模拟', '混合子集模拟'};
    times = zeros(3, 1);
    Pfs = zeros(3, 1);
    
    % 标准算法
    tic;
    [Pfs(1), ~] = subsetSimulation(g, dim, N, p0);
    times(1) = toc;
    
    % 自适应算法
    tic;
    [Pfs(2), ~] = adaptiveSubsetSimulation(g, dim, N, p0);
    times(2) = toc;
    
    % 混合算法
    tic;
    [Pfs(3), ~] = hybridSubsetSimulation(g, dim, N, p0);
    times(3) = toc;
    
    % 显示结果
    fprintf('\n算法性能比较:\n');
    fprintf('%-20s %-15s %-15s\n', '算法', '失效概率', '计算时间(s)');
    for i = 1:3
        fprintf('%-20s %-15.2e %-15.2f\n', algorithms{i}, Pfs(i), times(i));
    end
    
    % 绘制比较图
    figure('Position', [100, 100, 1200, 400]);
    
    subplot(1,2,1);
    bar(Pfs);
    set(gca, 'XTickLabel', algorithms);
    ylabel('失效概率');
    title('失效概率比较');
    grid on;
    
    subplot(1,2,2);
    bar(times);
    set(gca, 'XTickLabel', algorithms);
    ylabel('计算时间(s)');
    title('计算效率比较');
    grid on;
end

参考代码利用子集模拟进行系统和静态可靠性分析，子集模拟优化算法 www.3dddown.com/csb/113043.html

五、使用建议

标准子集模拟：适用于大多数问题，实现简单
自适应优化：当MCMC接受率不理想时使用
混合算法：适用于高维问题或复杂失效域
并行计算：当计算时间过长时考虑