构建AI智能体：Bootstrap采样在大模型评估中的应用：从置信区间到模型稳定性

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats

def plot_original_vs_true_distribution():
    """图1：原始数据分布与真实分布对比"""
    np.random.seed(42)
    
    # 参数设置
    true_mean = 50
    true_std = 8
    n_original = 100
    
    # 生成原始数据
    original_data = np.random.normal(true_mean, true_std, n_original)
    
    # 计算统计量
    original_mean = np.mean(original_data)
    original_std = np.std(original_data)
    original_se = original_std / np.sqrt(n_original)  # 标准误
    
    print("=== 计算内容 ===")
    print(f"真实总体参数: μ={true_mean}, σ={true_std}")
    print(f"样本统计量: 均值={original_mean:.3f}, 标准差={original_std:.3f}")
    print(f"标准误: {original_se:.3f}")
    print(f"抽样误差: {abs(original_mean - true_mean):.3f}")
    
    # 创建图表
    plt.figure(figsize=(10, 6))
    
    # 绘制原始数据直方图
    n_bins = 20
    counts, bins, patches = plt.hist(original_data, bins=n_bins, alpha=0.7, 
                                    color='skyblue', edgecolor='black', 
                                    label='原始样本数据', density=True)
    
    # 添加理论正态分布曲线
    x = np.linspace(original_data.min(), original_data.max(), 100)
    theoretical_pdf = stats.norm.pdf(x, true_mean, true_std)
    plt.plot(x, theoretical_pdf, 'r-', linewidth=2, label='真实总体分布')
    
    # 添加参考线
    plt.axvline(original_mean, color='blue', linestyle='--', linewidth=2, 
                label=f'样本均值: {original_mean:.2f}')
    plt.axvline(true_mean, color='red', linestyle='-', linewidth=2, 
                alpha=0.7, label=f'真实均值: {true_mean:.2f}')
    
    plt.xlabel('数值')
    plt.ylabel('概率密度')
    plt.title('图1: 原始数据分布与真实分布对比\n(展示抽样误差)', fontsize=14, fontweight='bold')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    # 添加统计信息文本框
    textstr = '\n'.join([
        f'样本大小: n={n_original}',
        f'样本均值: {original_mean:.3f}',
        f'样本标准差: {original_std:.3f}',
        f'抽样误差: {abs(original_mean-true_mean):.3f}'
    ])
    props = dict(boxstyle='round', facecolor='wheat', alpha=0.8)
    plt.text(0.02, 0.98, textstr, transform=plt.gca().transAxes, fontsize=10,
             verticalalignment='top', bbox=props)
    
    plt.tight_layout()
    plt.show()
    
    return original_data, original_mean, original_std

# 运行图1
original_data, sample_mean, sample_std = plot_original_vs_true_distribution()

def plot_bootstrap_sampling_process():
    """图2：Bootstrap采样过程示意图"""
    np.random.seed(123)
    
    # 创建小型示例数据集
    demo_data = np.array([10, 20, 30, 40, 50])
    data_labels = ['A', 'B', 'C', 'D', 'E']
    
    # 执行一次Bootstrap采样
    bootstrap_indices = np.random.choice(len(demo_data), size=len(demo_data), replace=True)
    bootstrap_sample = demo_data[bootstrap_indices]
    
    print("\n=== 计算内容 ===")
    print(f"原始数据集: {demo_data}")
    print(f"数据标签: {data_labels}")
    print(f"Bootstrap采样索引: {bootstrap_indices}")
    print(f"Bootstrap样本: {bootstrap_sample}")
    print(f"样本组成: {[data_labels[i] for i in bootstrap_indices]}")
    
    # 计算每个原始数据点在Bootstrap样本中出现的次数
    occurrence_count = {}
    for idx in bootstrap_indices:
        label = data_labels[idx]
        occurrence_count[label] = occurrence_count.get(label, 0) + 1
    
    print(f"数据点出现次数: {occurrence_count}")
    
    # 创建图表
    plt.figure(figsize=(12, 8))
    
    # 绘制原始数据集
    y_original = 6
    for i, (value, label) in enumerate(zip(demo_data, data_labels)):
        plt.plot(value, y_original, 'o', markersize=80, color='lightblue', alpha=0.8)
        plt.text(value, y_original, f'{label}\n{value}', ha='center', va='center', 
                fontweight='bold', fontsize=12)
    
    # 绘制Bootstrap样本
    y_bootstrap = 2
    for i, (value, label) in enumerate(zip(bootstrap_sample, [data_labels[idx] for idx in bootstrap_indices])):
        plt.plot(value, y_bootstrap, 'o', markersize=80, color='lightcoral', alpha=0.8)
        plt.text(value, y_bootstrap, f'{label}*\n{value}', ha='center', va='center', 
                fontweight='bold', fontsize=12)
    
    # 绘制采样连线
    for i, (orig_idx, bs_value) in enumerate(zip(bootstrap_indices, bootstrap_sample)):
        orig_x = demo_data[orig_idx]
        orig_y = y_original - 0.3
        bs_y = y_bootstrap + 0.3
        
        # 绘制箭头
        plt.annotate('', xy=(bs_value, bs_y), xytext=(orig_x, orig_y),
                    arrowprops=dict(arrowstyle='->', color='gray', lw=1.5, alpha=0.6))
    
    plt.xlim(0, 60)
    plt.ylim(0, 7)
    plt.xlabel('数据值')
    plt.title('图2: Bootstrap采样过程示意图\n(有放回随机抽样)', fontsize=14, fontweight='bold')
    plt.gca().set_yticks([y_original, y_bootstrap])
    plt.gca().set_yticklabels(['原始数据集', 'Bootstrap样本'])
    plt.grid(True, alpha=0.3)
    
    # 添加说明文本
    explanation_text = (
        "Bootstrap采样过程:\n"
        "1. 从原始数据集中有放回地随机抽取n个样本\n"
        "2. 某些原始数据点可能被多次抽取\n"
        "3. 某些原始数据点可能不被抽取\n"
        f"4. 本例中: {occurrence_count}"
    )
    plt.text(0.02, 0.15, explanation_text, transform=plt.gca().transAxes, fontsize=10,
             bbox=dict(boxstyle="round", facecolor="lightyellow", alpha=0.8))
    
    plt.tight_layout()
    plt.show()
    
    return bootstrap_sample, occurrence_count

# 运行图2
bootstrap_sample, occurrence_count = plot_bootstrap_sampling_process()

def plot_bootstrap_samples_comparison(original_data, n_bootstrap_samples=4):
    """图3：Bootstrap样本分布对比"""
    from sklearn.utils import resample
    
    np.random.seed(42)
    
    # 生成多个Bootstrap样本
    bootstrap_samples = []
    sample_means = []
    sample_stds = []
    
    for i in range(n_bootstrap_samples):
        bootstrap_sample = resample(original_data, replace=True, n_samples=len(original_data))
        bootstrap_samples.append(bootstrap_sample)
        sample_means.append(np.mean(bootstrap_sample))
        sample_stds.append(np.std(bootstrap_sample))
    
    print("\n=== 计算内容 ===")
    print(f"原始数据均值: {np.mean(original_data):.3f}")
    print(f"原始数据标准差: {np.std(original_data):.3f}")
    for i in range(n_bootstrap_samples):
        print(f"Bootstrap样本{i+1}: 均值={sample_means[i]:.3f}, 标准差={sample_stds[i]:.3f}")
    
    # 创建图表
    plt.figure(figsize=(12, 8))
    
    colors = ['lightgreen', 'lightcoral', 'gold', 'lightblue']
    
    # 绘制原始数据分布
    n_bins = 15
    counts_orig, bins_orig = np.histogram(original_data, bins=n_bins, density=True)
    bin_centers_orig = (bins_orig[:-1] + bins_orig[1:]) / 2
    plt.plot(bin_centers_orig, counts_orig, 'ko-', linewidth=3, 
            markersize=6, label='原始数据分布', alpha=0.8)
    
    # 绘制Bootstrap样本分布
    for i, sample in enumerate(bootstrap_samples):
        counts, bins = np.histogram(sample, bins=n_bins, density=True)
        bin_centers = (bins[:-1] + bins[1:]) / 2
        plt.plot(bin_centers, counts, 'o-', color=colors[i], alpha=0.8, 
                linewidth=2, markersize=4, label=f'Bootstrap样本 {i+1}')
    
    plt.xlabel('数值')
    plt.ylabel('概率密度')
    plt.title('图3: Bootstrap样本与原始数据分布对比\n(展示抽样变异性)', fontsize=14, fontweight='bold')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    # 添加统计比较表格
    col_labels = ['数据集', '均值', '标准差', '与原始均值差']
    cell_text = []
    
    cell_text.append(['原始数据', 
                     f'{np.mean(original_data):.3f}', 
                     f'{np.std(original_data):.3f}', 
                     '0.000'])
    
    for i in range(n_bootstrap_samples):
        mean_diff = sample_means[i] - np.mean(original_data)
        cell_text.append([f'Bootstrap样本{i+1}', 
                         f'{sample_means[i]:.3f}', 
                         f'{sample_stds[i]:.3f}', 
                         f'{mean_diff:+.3f}'])
    
    plt.table(cellText=cell_text, colLabels=col_labels,
              loc='bottom', bbox=[0.1, -0.5, 0.8, 0.3])
    
    plt.tight_layout()
    plt.subplots_adjust(bottom=0.3)
    plt.show()
    
    return bootstrap_samples, sample_means, sample_stds

# 运行图3
bootstrap_samples, bs_means, bs_stds = plot_bootstrap_samples_comparison(original_data)

def plot_bootstrap_means_distribution(original_data, n_bootstrap=1000):
    """图4：Bootstrap均值分布与置信区间"""
    from sklearn.utils import resample
    
    np.random.seed(42)
    
    # 执行大量Bootstrap采样
    bootstrap_means = []
    
    for i in range(n_bootstrap):
        bootstrap_sample = resample(original_data, replace=True, n_samples=len(original_data))
        bootstrap_means.append(np.mean(bootstrap_sample))
    
    bootstrap_means = np.array(bootstrap_means)
    
    # 计算统计量
    bootstrap_mean = np.mean(bootstrap_means)
    bootstrap_std = np.std(bootstrap_means)
    original_mean = np.mean(original_data)
    
    # 计算置信区间
    confidence_level = 0.95
    alpha = 1 - confidence_level
    ci_lower = np.percentile(bootstrap_means, 100 * alpha / 2)
    ci_upper = np.percentile(bootstrap_means, 100 * (1 - alpha / 2))
    
    # 正态分布拟合
    mu, sigma = stats.norm.fit(bootstrap_means)
    
    print("\n=== 计算内容 ===")
    print(f"Bootstrap次数: {n_bootstrap}")
    print(f"Bootstrap均值: {bootstrap_mean:.3f}")
    print(f"Bootstrap标准差: {bootstrap_std:.3f}")
    print(f"Bootstrap标准误: {bootstrap_std:.3f}")
    print(f"95%置信区间: [{ci_lower:.3f}, {ci_upper:.3f}]")
    print(f"区间宽度: {ci_upper - ci_lower:.3f}")
    print(f"正态拟合参数: μ={mu:.3f}, σ={sigma:.3f}")
    
    # 创建图表
    plt.figure(figsize=(12, 8))
    
    # 绘制Bootstrap均值的直方图
    n, bins, patches = plt.hist(bootstrap_means, bins=30, alpha=0.7, 
                               color='lightseagreen', edgecolor='black', 
                               density=True, label='Bootstrap均值分布')
    
    # 添加正态分布拟合曲线
    x = np.linspace(bootstrap_means.min(), bootstrap_means.max(), 100)
    fitted_pdf = stats.norm.pdf(x, mu, sigma)
    plt.plot(x, fitted_pdf, 'r-', linewidth=3, 
            label=f'正态分布拟合\n(μ={mu:.3f}, σ={sigma:.3f})')
    
    # 添加置信区间
    plt.axvline(ci_lower, color='red', linestyle='--', linewidth=2, 
                label=f'95% 置信区间\n[{ci_lower:.3f}, {ci_upper:.3f}]')
    plt.axvline(ci_upper, color='red', linestyle='--', linewidth=2)
    plt.axvline(original_mean, color='blue', linestyle='-', linewidth=2, 
                label=f'原始样本均值: {original_mean:.3f}')
    
    # 填充置信区间区域
    y_max = max(n) * 1.1
    plt.fill_betweenx([0, y_max], ci_lower, ci_upper, alpha=0.2, color='red')
    
    plt.xlabel('Bootstrap样本均值')
    plt.ylabel('概率密度')
    plt.title('图4: Bootstrap均值分布与置信区间\n(估计参数不确定性)', fontsize=14, fontweight='bold')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    # 添加统计信息
    stats_text = f"""Bootstrap分析结果:
• Bootstrap次数: {n_bootstrap}
• Bootstrap均值: {bootstrap_mean:.3f}
• Bootstrap标准差: {bootstrap_std:.3f}
• 95%置信区间: [{ci_lower:.3f}, {ci_upper:.3f}]
• 区间宽度: {ci_upper-ci_lower:.3f}
• 包含原始均值: {'是' if ci_lower <= original_mean <= ci_upper else '否'}"""
    
    plt.text(0.02, 0.98, stats_text, transform=plt.gca().transAxes, fontsize=10,
             verticalalignment='top', bbox=dict(boxstyle="round", facecolor="wheat", alpha=0.8))
    
    plt.tight_layout()
    plt.show()
    
    return bootstrap_means, (ci_lower, ci_upper), (mu, sigma)

# 运行图4
bootstrap_means, confidence_interval, normal_params = plot_bootstrap_means_distribution(original_data)

def plot_sample_size_effect(original_data):
    """图5：样本大小对Bootstrap稳定性的影响"""
    np.random.seed(42)
    
    # 测试不同的样本大小
    sample_sizes = [10, 20, 30, 50, 100, 200]
    bootstrap_stds = []
    theoretical_stds = []
    
    for size in sample_sizes:
        if size <= len(original_data):
            # 从原始数据中抽取子样本
            sample_data = np.random.choice(original_data, size=size, replace=False)
        else:
            sample_data = original_data
        
        # 执行Bootstrap
        temp_means = []
        n_bootstrap = 500
        
        for _ in range(n_bootstrap):
            bootstrap_sample = resample(sample_data, replace=True, n_samples=len(sample_data))
            temp_means.append(np.mean(bootstrap_sample))
        
        bootstrap_std = np.std(temp_means)
        bootstrap_stds.append(bootstrap_std)
        
        # 理论标准误
        theoretical_std = np.std(sample_data) / np.sqrt(size)
        theoretical_stds.append(theoretical_std)
    
    print("\n=== 计算内容 ===")
    print("样本大小对Bootstrap稳定性的影响:")
    for i, size in enumerate(sample_sizes):
        print(f"n={size}: Bootstrap标准差={bootstrap_stds[i]:.4f}, 理论标准误={theoretical_stds[i]:.4f}")
    
    # 创建图表
    plt.figure(figsize=(12, 8))
    
    # 绘制Bootstrap标准差
    plt.plot(sample_sizes, bootstrap_stds, 'o-', 
            linewidth=3, markersize=8, color='purple', 
            label='Bootstrap标准差', markerfacecolor='yellow')
    
    # 绘制理论标准误
    plt.plot(sample_sizes, theoretical_stds, 's-', 
            linewidth=2, markersize=6, color='red', 
            label='理论标准误', alpha=0.7)
    
    plt.xlabel('样本大小 (n)')
    plt.ylabel('均值估计的标准差')
    plt.title('图5: 样本大小对Bootstrap稳定性的影响\n(标准误随样本增大而减小)', fontsize=14, fontweight='bold')
    plt.grid(True, alpha=0.3)
    plt.legend()
    
    # 设置对数坐标
    plt.xscale('log')
    
    # 添加趋势线说明
    plt.text(0.05, 0.95, '趋势: 标准误 ∝ 1/√n', transform=plt.gca().transAxes, fontsize=12,
             bbox=dict(boxstyle="round", facecolor="lightblue", alpha=0.8))
    
    # 添加数据表格
    col_labels = ['样本大小', 'Bootstrap标准差', '理论标准误', '相对误差%']
    cell_text = []
    
    for i, size in enumerate(sample_sizes):
        rel_error = abs(bootstrap_stds[i] - theoretical_stds[i]) / theoretical_stds[i] * 100
        cell_text.append([
            str(size),
            f'{bootstrap_stds[i]:.4f}',
            f'{theoretical_stds[i]:.4f}',
            f'{rel_error:.2f}%'
        ])
    
    plt.table(cellText=cell_text, colLabels=col_labels,
              loc='bottom', bbox=[0.1, -0.5, 0.8, 0.4])
    
    plt.tight_layout()
    plt.subplots_adjust(bottom=0.4)
    plt.show()
    
    return sample_sizes, bootstrap_stds, theoretical_stds

# 运行图5
sample_sizes, bs_stds, theory_stds = plot_sample_size_effect(original_data)

def plot_confidence_interval_coverage():
    """图6：置信区间覆盖概率验证"""
    np.random.seed(42)
    
    # 模拟参数
    true_mean = 50
    true_std = 8
    n_original = 100
    n_simulations = 100
    confidence_level = 0.95
    
    coverage_count = 0
    ci_widths = []
    simulation_results = []
    
    for sim in range(n_simulations):
        # 生成新的样本（模拟重复实验）
        new_sample = np.random.normal(true_mean, true_std, n_original)
        
        # 计算该样本的Bootstrap置信区间
        sim_means = []
        n_bootstrap = 500
        
        for _ in range(n_bootstrap):
            bootstrap_sample = resample(new_sample, replace=True, n_samples=len(new_sample))
            sim_means.append(np.mean(bootstrap_sample))
        
        sim_ci_lower = np.percentile(sim_means, 100 * (1-confidence_level)/2)
        sim_ci_upper = np.percentile(sim_means, 100 * (1 - (1-confidence_level)/2))
        
        ci_width = sim_ci_upper - sim_ci_lower
        ci_widths.append(ci_width)
        
        # 检查是否覆盖真实均值
        covers_true_mean = sim_ci_lower <= true_mean <= sim_ci_upper
        if covers_true_mean:
            coverage_count += 1
        
        simulation_results.append({
            'lower': sim_ci_lower,
            'upper': sim_ci_upper,
            'width': ci_width,
            'covers': covers_true_mean,
            'sample_mean': np.mean(new_sample)
        })
    
    coverage_rate = coverage_count / n_simulations
    
    print("\n=== 计算内容 ===")
    print(f"模拟实验次数: {n_simulations}")
    print(f"置信水平: {confidence_level}")
    print(f"覆盖真实均值的次数: {coverage_count}")
    print(f"覆盖概率: {coverage_rate:.3f}")
    print(f"期望覆盖概率: {confidence_level}")
    print(f"平均置信区间宽度: {np.mean(ci_widths):.3f}")
    
    # 创建图表
    plt.figure(figsize=(12, 10))
    
    # 绘制前30个模拟实验的置信区间
    n_to_plot = min(30, n_simulations)
    
    for i in range(n_to_plot):
        result = simulation_results[i]
        color = 'green' if result['covers'] else 'red'
        plt.plot([result['lower'], result['upper']], [i, i], 
                color=color, linewidth=2, alpha=0.7)
        plt.plot(result['sample_mean'], i, 'o', color='blue', markersize=4)
    
    # 添加真实均值线
    plt.axvline(true_mean, color='black', linestyle='-', linewidth=3, 
                label=f'真实均值: {true_mean:.2f}')
    
    plt.xlabel('均值估计')
    plt.ylabel('模拟实验序号')
    plt.title(f'图6: 置信区间覆盖概率验证\n(实际覆盖概率: {coverage_rate:.3f}, 期望: {confidence_level})', 
              fontsize=14, fontweight='bold')
    plt.grid(True, alpha=0.3)
    plt.legend()
    
    # 添加覆盖概率信息
    coverage_info = f"""覆盖概率分析:
• 模拟实验次数: {n_simulations}
• 覆盖真实均值次数: {coverage_count}
• 实际覆盖概率: {coverage_rate:.3f}
• 期望覆盖概率: {confidence_level}
• 平均区间宽度: {np.mean(ci_widths):.3f}
• 覆盖误差: {abs(coverage_rate-confidence_level):.3f}"""
    
    plt.text(0.02, 0.98, coverage_info, transform=plt.gca().transAxes, fontsize=10,
             verticalalignment='top', bbox=dict(boxstyle="round", facecolor="lightblue", alpha=0.8))
    
    # 添加图例说明
    legend_elements = [
        plt.Line2D([0], [0], color='green', lw=2, label='覆盖真实均值'),
        plt.Line2D([0], [0], color='red', lw=2, label='未覆盖真实均值'),
        plt.Line2D([0], [0], marker='o', color='blue', label='样本均值', linestyle='None')
    ]
    plt.legend(handles=legend_elements, loc='lower right')
    
    plt.tight_layout()
    plt.show()
    
    return coverage_rate, np.mean(ci_widths), simulation_results

# 运行图6
coverage_rate, avg_ci_width, sim_results = plot_confidence_interval_coverage()

def plot_bootstrap_vs_traditional(original_data, true_mean=50):
    """图7：Bootstrap与传统置信区间方法比较"""
    
    # Bootstrap置信区间（使用之前的结果）
    bootstrap_ci_lower, bootstrap_ci_upper = confidence_interval
    bootstrap_mean = np.mean(bootstrap_means)
    
    # 传统正态近似置信区间
    original_mean = np.mean(original_data)
    original_std = np.std(original_data)
    n = len(original_data)
    
    # 计算传统置信区间
    z_score = stats.norm.ppf(0.975)  # 95%置信水平的z值
    margin_of_error = z_score * (original_std / np.sqrt(n))
    traditional_ci_lower = original_mean - margin_of_error
    traditional_ci_upper = original_mean + margin_of_error
    
    print("\n=== 计算内容 ===")
    print("Bootstrap方法:")
    print(f"  置信区间: [{bootstrap_ci_lower:.3f}, {bootstrap_ci_upper:.3f}]")
    print(f"  区间宽度: {bootstrap_ci_upper - bootstrap_ci_lower:.3f}")
    
    print("\n传统正态近似方法:")
    print(f"  置信区间: [{traditional_ci_lower:.3f}, {traditional_ci_upper:.3f}]")
    print(f"  区间宽度: {traditional_ci_upper - traditional_ci_lower:.3f}")
    print(f"  z值: {z_score:.3f}")
    print(f"  误差范围: {margin_of_error:.3f}")
    
    print(f"\n比较:")
    print(f"  区间宽度差异: {abs((bootstrap_ci_upper-bootstrap_ci_lower) - (traditional_ci_upper-traditional_ci_lower)):.3f}")
    print(f"  是否都包含真实均值: {bootstrap_ci_lower <= true_mean <= bootstrap_ci_upper and traditional_ci_lower <= true_mean <= traditional_ci_upper}")
    
    # 创建图表
    plt.figure(figsize=(12, 8))
    
    methods = ['Bootstrap', '传统正态近似']
    ci_lowers = [bootstrap_ci_lower, traditional_ci_lower]
    ci_uppers = [bootstrap_ci_upper, traditional_ci_upper]
    means = [bootstrap_mean, original_mean]
    
    colors = ['lightcoral', 'lightblue']
    
    # 绘制置信区间
    for i, method in enumerate(methods):
        # 绘制误差条
        plt.errorbar(means[i], i, 
                    xerr=[[means[i] - ci_lowers[i]], [ci_uppers[i] - means[i]]],
                    fmt='o', color=colors[i], ecolor='black', 
                    elinewidth=3, capsize=8, capthick=2, 
                    markersize=10, label=method)
    
    # 添加真实均值线
    plt.axvline(true_mean, color='red', linestyle='--', linewidth=3, 
                label=f'真实均值: {true_mean:.2f}')
    
    plt.yticks(range(len(methods)), methods)
    plt.xlabel('均值估计')
    plt.title('图7: Bootstrap vs 传统置信区间方法比较\n(在正态数据下的表现相似性)', fontsize=14, fontweight='bold')
    plt.grid(True, alpha=0.3)
    plt.legend()
    
    # 添加详细比较信息
    comparison_text = f"""方法比较:
Bootstrap方法:
• 区间: [{bootstrap_ci_lower:.3f}, {bootstrap_ci_upper:.3f}]
• 宽度: {bootstrap_ci_upper-bootstrap_ci_lower:.3f}

传统方法:
• 区间: [{traditional_ci_lower:.3f}, {traditional_ci_upper:.3f}]
• 宽度: {traditional_ci_upper-traditional_ci_lower:.3f}
• z值: {z_score:.3f}

真实均值: {true_mean:.2f}
两者差异: {abs((bootstrap_ci_upper-bootstrap_ci_lower) - (traditional_ci_upper-traditional_ci_lower)):.3f}"""
    
    plt.text(0.02, 0.98, comparison_text, transform=plt.gca().transAxes, fontsize=10,
             verticalalignment='top', bbox=dict(boxstyle="round", facecolor="lightyellow", alpha=0.8))
    
    plt.tight_layout()
    plt.show()
    
    return {
        'bootstrap': (bootstrap_ci_lower, bootstrap_ci_upper),
        'traditional': (traditional_ci_lower, traditional_ci_upper),
        'width_difference': abs((bootstrap_ci_upper-bootstrap_ci_lower) - (traditional_ci_upper-traditional_ci_lower))
    }

# 运行图7
ci_comparison = plot_bootstrap_vs_traditional(original_data)