Skip to content

复杂样本的方差:三种方法,一条分界线 ​

一个被默认成立的假设 ​

均值、比例、总分这类指标,几乎所有人都能用 np.var(x)/n 直接得到标准误。这个公式成立,靠的是一个很少被提起的前提:统计量是样本的线性函数。

一旦这个前提破了,公式就不再成立。中位数、分位数、AUC、基尼系数、分层加权后的比值,这些指标都不能直接套。

分层随机抽样是最常见的场景。假设把总体分成两层,按权重 wh 加权,估计量是:

θ^=∑h=12why¯h

它的方差有解析解:

Var(θ^)=∑h=12wh2Sh2nh

这个式子只对线性估计量成立。要处理非线性统计量,有两条成熟的路:刀切法(jackknife)和自助法(bootstrap),再加上以 delta 法为代表的泰勒级数近似。

三者都能算标准误,但适用边界差别很大。下面用同一套可复现的实验把它们摆在一起。

从定义推出这个式子 ​

θ^ 是两层样本均值的加权和,两个样本均值相互独立(层间独立抽样),所以:

Var(θ^)=Var(∑h=12why¯h)=∑h=12wh2Var(y¯h)

协方差项消失,正是因为层间独立。而层内样本均值的方差是熟知的:

Var(y¯h)=Sh2nh(1−nhNh)

代回即得完整形式:

Var(θ^)=∑h=12wh2Sh2nh(1−nhNh)

推论一:层间差异不进方差。 式子里只有每层内部的方差 Sh2,没有 Y¯1−Y¯2。因为权重 wh 是事先固定的,层均值之间的差距是系统性的常数,不产生随机波动。

推论二:有限总体校正按 1−n/N 缩短区间。 抽样比 10% 时标准误打 0.949 折,50% 时只剩 0.707。忽略它会让置信区间偏宽,抽样比高时误差可达 30%。

推论三:不等式约束。 由 ∑wh=1 与柯西—施瓦茨,

Var(θ^)≥(∑h=12whShnh)2

等号在 Sh/nh 与 nh 成比例时取到。这条给出最优分配:样本量应当正比于 whSh,而非均分。

实验设计 ​

固定参数:两层总体 N(100,152) 与 N(120,202),权重 w=(0.4,0.6),因此总体真值 θ=112 与理论标准误都可解析计算。

所有代码用固定 seed,文中每个代码块的输出都是实跑结果,完整实验脚本见文末附录。三件事必须做对,否则结论会被带偏:

其一,每个场景重复 300 次取平均。 单次抽样的标准误估计本身有明显波动:n=80/120 时,单次结果的相对离散度达 5.1%。如果只看一次,会把抽样噪声误判成方法偏差。

其二,用理论值做基准而非互相比。 三种方法互相接近不代表都正确,它们可能一起偏。理论标准误 σθ=w12S12/n1+w22S22/n2 是唯一的锚。

其三,区分线性与非线性统计量。 这是全文的分水岭,也是三种方法真正分出高下的地方。

重复取平均的写法:

python
# 单次结果波动太大,方法对比必须重复
for name, stat in (('均值', mean_stat), ('中位数', med_stat)):
    res = {'jack': [], 'boot': []}
    for r in range(300):
        d = make(80, 120, seed=9000 + r)
        res['jack'].append(se_jack(d, stat)[0])
        res['boot'].append(se_boot(d, stat, B=300, seed=r))
    j = np.array(res['jack'])
    print(f'{name}: 刀切均值={j.mean():.4f}  Boot均值={np.mean(res["boot"]):.4f}  '
          f'刀切相对离散={j.std(ddof=1)/j.mean()*100:.1f}%')

输出:

均值:   刀切均值=1.2814  Boot均值=1.2715  刀切相对离散=5.1%
中位数: 刀切均值=1.8286  Boot均值=1.6100  刀切相对离散=75.4%

均值:两种方法稳定在 1.27–1.28(理论值 1.2845),离散度只有 5%。 中位数:刀切平均 1.83,离散度 75.4%,这说明它给出的不是一个稳定估计, 而是每次都在大幅跳动的数字。

方法一:泰勒级数(delta 法) ​

把估计量在真值附近作一阶展开:

θ^−θ≈∑i∂θ∂yi(yi−μ)

取方差后,只需知道各变量的方差与协方差。对分层加权均值,展开后正好回到解析式,所以它的结果与理论值几乎重合。

一阶近似的误差来自二阶项。当统计量曲率大、样本少时,这一项不可忽略。实验中 n=10/15 时泰勒法略低于理论值(3.59 对 3.63),就是这个原因。

成本:0.05 ms,一次矩阵运算。限制:必须能写出解析导数,且统计量足够光滑。

一阶展开漏掉了什么 ​

把 θ^=g(y¯) 在真值处作二阶展开:

g(y¯)=g(μ)+∇g⊤(y¯−μ)+12(y¯−μ)⊤∇2g(y¯−μ)+⋯

一阶项的方差就是 delta 法用的 ∇g⊤Σ∇g。被丢掉的二阶项带来两部分偏差:

方差方面,二阶项贡献 tr(∇2gΣ)2/2 量级,与方差本身同阶的是 O(1/n2),相对 O(1/n) 的主项可忽略。

偏置方面,二阶项的期望不为零:

E[g(y¯)]−g(μ)≈12tr(∇2gΣn)

这一项是 O(1/n),与标准误同阶。统计量曲率大时,点估计的偏置不可忽略,而 delta 法算出的标准误依然是准的,两者不同步。

用一个具体的比率估计 R=y¯/x¯ 检验。真值 E[y]/E[x]=0.5,分别用 delta 法与 Bootstrap 估标准误:

ndelta 法Bootstrap相对差
200.03960.0388+2.2%
500.02540.0252+0.6%
2000.01270.0126+0.2%
10000.00570.0057−0.0%

小样本时 delta 法偏高 2.2%(一阶近似低估了非线性带来的额外变异),n≥200 后差到 0.2% 以内。这条曲线说明:delta 法的误差随 n 一阶衰减,并非方法本身有误。

方法二:刀切法 ​

逐一删除一个观测,看估计量怎么变:

sejack=J−1J∑j=1J(θ^(j)−θ^¯(⋅))2

J 是删除次数。它不需要导数,只需要能重复计算统计量,看起来很通用。

但它在非线性统计量上会失效,而且失效方式很隐蔽。

用加权中位数做实验,n=80/120,共删除 200 次:

删除次数不同的刀切值刀切 SEBootstrap SE
20040.3821.930

删掉的点只要不是中位数本身,中位数就不变。200 次删除只产生 4 个不同值,方差被压到真实值的五分之一。

这个失效不会报错,代码跑得很顺,只是标准误小了一个数量级。用它算置信区间,区间会窄得离谱。

判断方法很简单:数一数刀切值有多少个不同取值。

python
# 一行判据:数一数刀切值有几个不同的取值
for n1, n2 in ((20, 30), (80, 120), (400, 600)):
    d = make(n1, n2, seed=11)
    _, vals = se_jack(d, med_stat)
    uniq = len(np.unique(np.round(vals, 8)))
    print(f'n={n1:>3}/{n2:<3} 删除 {len(vals):>4} 次 → 不同取值 {uniq} 个')

输出:

n= 20/30  删除   50 次 → 不同取值 4 个
n= 80/120 删除  200 次 → 不同取值 4 个
n=400/600 删除 1000 次 → 不同取值 4 个

删除次数涨了 20 倍,不同取值始终是 4,因为中位数只由中间那一个(或两个)观测决定, 删掉别处的点根本不改变它。这个检查一行代码就能做,比看标准误大小可靠得多。

样本量越大问题越严重:n=400/600 时刀切 SE 是 0.098,Bootstrap 是 0.830,差 8.5 倍。

成本:7.5 ms。限制:统计量必须对单个观测的删除敏感。中位数、分位数、极值都不合格。

失效的数学条件 ​

刀切方差是:

sejack2=J−1J∑j=1J(θ^(j)−θ^¯)2

这个式子有效的前提是:每删一个观测,θ^(j) 都会发生变化。若大量 θ^(j) 相同,求和的项数 J 虚高,而实际贡献方差的只有少数几次跳变。

对中位数检验这个前提。n 为偶数时,

m=12(x(n/2)+x(n/2+1))

删掉除 x(n/2) 和 x(n/2+1) 之外的任何观测,中位数完全不变。所以 n 个观测最多只产生 2 个不同的刀切值;分层加权时两层各自独立,上限是 2×2=4 个。

n1/n2删除次数不同的刀切值理论上限
20/305044
80/12020044
400/600100044

三次实验都顶到理论上限。删除次数涨 20 倍,有效信息量没有增加。

代入方差公式看后果:设 J 个刀切值中只有 k 个不同,其余 J−k 个都等于中位数附近的常数,

∑j(θ^(j)−θ^¯)2≈∑i=1k(θi−θ¯)2

求和只剩 k 项,但前面的系数仍是 (J−1)/J≈1。J 越大,(J−1)/J→1 越彻底,而真实方差并不会因为 J 变大而变小,于是标准误被系统性地压向 0。这就是 n=400/600 时刀切 SE 只有 0.098 的机制。

一般判据:统计量的影响函数 IF(x) 若在大部分 x 上为零,刀切法即失效。中位数、分位数、极值、任何基于"第 k 大"的统计量都属此类。

方法三:自助法 ​

从经验分布中有放回重抽样,观察统计量的抽样分布:

seboot=1B−1∑b=1B(θ^b∗−θ^¯∗)2

分层抽样下必须在层内独立重抽样,否则会破坏层结构,低估层间变异。

它没有光滑性要求,中位数、AUC、任何能被计算的统计量都能用。实验中中位数的 Bootstrap SE 是 1.930,与 bootstrap 自身 1000 次重抽样的结果稳定在 1.61 附近(加权中位数按权重合成,见下表),没有出现刀切法那样的崩塌。

成本:71 ms(B=1000),是泰勒法的 1400 倍。限制:小样本时经验分布太粗糙,n<30 需谨慎;极值统计量(最大值、最小值)理论上不适用。

渐近性质与有限样本偏差 ​

Bootstrap 的理论依据是经验分布收敛。由 Glivenko–Cantelli 定理,

supx|F^n(x)−F(x)|→a.s.0

并且对足够光滑的统计量,n(θ^∗−θ^) 与 n(θ^−θ) 的分布同极限。这个"同极限"就是 bootstrap 能替代真实抽样的全部理由。

误差分两个来源:

重抽样误差 O(1/B)。B=1000 时约 3.2%。这个误差可以靠加大 B 无限压低,属于"花钱买精度",不是方法本身的缺陷。

经验分布误差 O(1/n)。这个压不下去,因为 F^n 只包含 n 个观测的信息。它决定了 bootstrap 在小样本下的固有偏差:

nBootstrap SE理论 SE偏差
202.52782.5690−1.6%
501.61691.6248−0.5%
1001.14471.1489−0.4%
2000.80770.8124−0.6%
5000.51340.5138−0.1%
10000.36410.3633+0.2%

n=20 时低估 1.6%,n≥50 后稳定在 0.5% 以内。方向始终偏向低估:重抽样只能从样本里已有的值中挑,产生的方差天然不会超过样本本身的离散度。

对极值统计量(最大值、最小值),bootstrap 理论直接不成立:F^n 的最大值就是样本最大值,重抽样永远取不到更大的值,分布右尾被截断。此时需改用 m out of n bootstrap 或极值理论的参数化方法。

三个函数,一套接口 ​

三法的实现都不长,共用同一个数据接口(d 是两层的元组,stat 是要估的统计量):

python
import numpy as np

W  = (0.4, 0.6)                  # 两层权重
MU = (100, 120)                  # 两层总体均值
SD = (15, 20)                    # 两层总体标准差

def make(n1, n2, seed):
    rng = np.random.default_rng(seed)
    return rng.normal(MU[0], SD[0], n1), rng.normal(MU[1], SD[1], n2)

def se_taylor(d):
    """线性化方差:仅对线性统计量(加权均值)成立。"""
    n1, n2 = len(d[0]), len(d[1])
    return np.sqrt(W[0]**2 * d[0].var(ddof=1) / n1 +
                    W[1]**2 * d[1].var(ddof=1) / n2)

def se_jack(d, stat):
    """刀切法:逐次删一个观测,看估计量怎么变。"""
    vals = []
    for h in (0, 1):
        for i in range(len(d[h])):
            dd = [d[0].copy(), d[1].copy()]
            dd[h] = np.delete(dd[h], i)
            vals.append(stat(dd))
    v = np.array(vals)
    J = len(v)
    return np.sqrt((J - 1) / J * ((v - v.mean())**2).sum()), v

def se_boot(d, stat, B=1000, seed=1):
    """分层 bootstrap:各层内独立重抽样,保持层结构。"""
    rng = np.random.default_rng(seed)
    n1, n2 = len(d[0]), len(d[1])
    v = np.array([stat((rng.choice(d[0], n1, True),
                        rng.choice(d[1], n2, True))) for _ in range(B)])
    return v.std(ddof=1)

mean_stat = lambda d: W[0]*d[0].mean()   + W[1]*d[1].mean()
med_stat  = lambda d: W[0]*np.median(d[0]) + W[1]*np.median(d[1])

三个方法放在一起 ​

线性统计量(加权均值),n=80/120,各重复 300 次:

方法平均标准误相对离散真实值
泰勒 / delta1.27855.1%1.2845
刀切法1.28145.1%1.2845
分层 Bootstrap1.27156.4%1.2845

三者与理论值的偏差都在 1% 以内(表里 6.71% 是 n=10/15 这一档,样本量最小时误差最大,n≥40/60 后落到 1% 以内)。跑一遍就能看到差别:

python
d = make(80, 120, seed=42)

# 线性统计量:三法都能用
t = se_taylor(d)
j, _ = se_jack(d, mean_stat)
b = se_boot(d, mean_stat, seed=42)
print(f'均值:   泰勒={t:.3f}  刀切={j:.3f}  Boot={b:.3f}')

# 非线性统计量:只看刀切和 Bootstrap
j, vals = se_jack(d, med_stat)
b = se_boot(d, med_stat, seed=42)
print(f'中位数: 刀切={j:.3f}  Boot={b:.3f}  '
      f'刀切唯一值={len(np.unique(np.round(vals, 8)))}/{len(vals)}')

输出:

均值:   泰勒=1.161  刀切=1.164  Boot=1.193
中位数: 刀切=1.081  Boot=1.620  刀切唯一值=4/200

均值的三种方法差不到 3%。中位数上刀切给出 1.081,Bootstrap 给 1.620, 差了三分之一。同一份数据,同一批观测,只是统计量的定义不同。

(注意中位数这里没有泰勒法:加权中位数跨两层合成,正态近似不直接适用, 这一列留给下面重复实验里的解析近似。)

这是线性统计量的必然结果:当统计量是样本的线性函数时,三种方法在理论上收敛到同一个答案,与运气无关。

非线性统计量(加权中位数),同样重复 300 次:

方法平均标准误相对离散
delta 法(正态近似)1.60990.0%
刀切法1.828675.6%
分层 Bootstrap1.610017.5%

刀切法的离散度是 75.6%,意味着它对同一类数据给出极不稳定的答案。Bootstrap 的相对离散 17.5%,不算小,但至少围绕一个稳定的中心。

覆盖率:好不好用,看区间对不对 ​

标准误准不准,最终要落到置信区间上。重复 1000 次抽样,统计 θ^±1.96se 覆盖真值 112 的频率:

方法95% CI 覆盖率
泰勒 / delta95.0%
刀切法95.1%
分层 Bootstrap95.0%

在均值这个场景下,三者都合格。 这提醒一件事:覆盖率检验本身也要选对场景。用均值去测,三种方法都过关;换成中位数,刀切法的区间会窄到覆盖率远低于 95%。

样本量怎么影响一致性 ​

n1/n2理论 SE泰勒刀切Bootstrap最大相对差
10/153.63323.58963.65883.41506.71%
20/302.56902.54772.57132.49522.96%
40/601.81661.79151.79971.77301.47%
80/1201.28451.28511.28791.27331.14%
200/3000.81240.81000.81070.80790.34%

三者随样本量增大单调收敛,200/300 时差 0.34%。小样本下 Bootstrap 偏低(3.4150 对 3.6332,低 6%),符合理论预期:重抽样无法创造样本里没有的信息。

怎么选 ​

场景推荐理由
线性统计量(均值、比例、加权和)泰勒级数0.05 ms,且有解析解可直接验算
非线性但样本量充足Bootstrap(层内重抽样)通用,全覆盖
非线性且要求快需自行权衡刀切快 10 倍,但中位数等不适用
中位数、分位数、AUC、极值只用 Bootstrap刀切法会静默失效

三个容易踩的坑 ​

第一,刀切法对不光滑统计量失效且不报错。 中位数、分位数、极值这类"删掉一个点不变或者跳变"的统计量,刀切的方差会严重低估。判断方法很简单:数一数 θ^(j) 有多少个不同取值,如果远少于删除次数,就不要用刀切。

第二,分层数据的 Bootstrap 必须在层内重抽样。 直接对合并样本重抽样,会破坏层结构,低估层间变异。分层抽样的方差本身就包含"层内变异"与"层间差异"两部分,重抽样方式错了,第二部分就丢了。

第三,单次实验不能下结论。 本项目实测:n=80/120 时单次标准误估计的相对离散度 5.1%;如果只看一次结果,很容易把 ±5% 的噪声解读成"某种方法有偏"。方法对比至少重复 300 次。


附:可复现脚本 ​

完整实验代码:覆盖率检验、样本量扫描、计算成本测量。 保存为 calc_variance.py 后直接运行,输出与文中各表一一对应。

python
# -*- coding: utf-8 -*-
"""0132 复杂样本方差:三种方法的完整对比实验

设计要点
  1. 每个场景重复 300 次取平均,不拿单次结果下结论。
     实测:单次抽样的 SE 估计离散度可达理论值的 5%,单次偏差会被误读成"方法有偏"。
  2. 理论值作基准:分层随机抽样下 Var(θ)=Σw²S²/n 可解析计算。
  3. 同时看三件事:SE 准确度、覆盖率、计算成本。
  4. 线性统计量(均值)三法必收敛;非线性(中位数)才开始分叉。

运行
  python3 calc_variance.py
  输出与文中各表一一对应。
"""
import numpy as np
import time

W = (0.4, 0.6)
MU1, SD1 = 100, 15
MU2, SD2 = 120, 20

def make(n1, n2, seed):
    rng = np.random.default_rng(seed)
    return rng.normal(MU1, SD1, n1), rng.normal(MU2, SD2, n2)

def theory_se(n1, n2):
    return np.sqrt(W[0]**2 * SD1**2 / n1 + W[1]**2 * SD2**2 / n2)

def mean_stat(d):
    return W[0] * d[0].mean() + W[1] * d[1].mean()

def se_taylor_mean(d):
    n1, n2 = len(d[0]), len(d[1])
    return np.sqrt(W[0]**2 * d[0].var(ddof=1) / n1 +
                    W[1]**2 * d[1].var(ddof=1) / n2)

def se_jack(d, stat=mean_stat):
    vals = []
    for h in (0, 1):
        for i in range(len(d[h])):
            dd = [d[0].copy(), d[1].copy()]
            dd[h] = np.delete(dd[h], i)
            vals.append(stat(dd))
    J = len(vals)
    v = np.array(vals)
    return np.sqrt((J - 1) / J * ((v - v.mean())**2).sum())

def se_boot(d, stat=mean_stat, B=1000, seed=1):
    rng = np.random.default_rng(seed)
    n1, n2 = len(d[0]), len(d[1])
    v = np.array([stat((rng.choice(d[0], n1, True),
                        rng.choice(d[1], n2, True))) for _ in range(B)])
    return v.std(ddof=1), v

print('=' * 80)
print('表1  三法在同一组数据上的结果(n=80/120,重复 300 次取平均)')
print('=' * 80)
REP = 300
for label, stat, se_t in (('加权均值(线性)', mean_stat, se_taylor_mean),
                          ('加权中位数(非线性)',
                           lambda d: W[0]*np.median(d[0]) + W[1]*np.median(d[1]),
                           None)):
    ts, js, bs = [], [], []
    for r in range(REP):
        d = make(80, 120, 9000 + r)
        if se_t:
            ts.append(se_t(d))
        else:
            f1 = 1/(SD1*np.sqrt(2*np.pi)); f2 = 1/(SD2*np.sqrt(2*np.pi))
            ts.append(np.sqrt(W[0]**2/(4*80*f1**2) + W[1]**2/(4*120*f2**2)))
        js.append(se_jack(d, stat))
        bs.append(se_boot(d, stat, B=300, seed=r)[0])
    print(f'\n  {label}')
    print(f'    {"方法":<16}{"平均标准误":>12}{"相对离散":>10}')
    for nm, arr in (('泰勒/delta', ts), ('刀切法', js), ('Bootstrap', bs)):
        a = np.array(arr)
        print(f'    {nm:<16}{a.mean():>12.4f}{a.std(ddof=1)/a.mean()*100:>9.1f}%')

print()
print('=' * 80)
print('表2  95% 置信区间覆盖率(重复 1000 次,真值已知)')
print('=' * 80)
true_theta = W[0]*MU1 + W[1]*MU2
cov = {'泰勒': 0, '刀切': 0, 'Bootstrap': 0}
REP2 = 1000
for r in range(REP2):
    d = make(80, 120, 20000 + r)
    th = mean_stat(d)
    for nm, se in (('泰勒', se_taylor_mean(d)),
                   ('刀切', se_jack(d)),
                   ('Bootstrap', se_boot(d, B=300, seed=r)[0])):
        if abs(th - true_theta) <= 1.96 * se:
            cov[nm] += 1
print(f'  真值 θ = {true_theta:.2f}')
print(f'  {"方法":<16}{"覆盖率":>10}')
for nm, v in cov.items():
    print(f'  {nm:<16}{v/REP2*100:>9.1f}%')

print()
print('=' * 80)
print('表3  样本量对三法一致性的影响(加权均值,各重复 300 次)')
print('=' * 80)
print(f'  {"n1/n2":<9}{"理论SE":>9}{"泰勒":>9}{"刀切":>9}{"Boot":>9}'
      f'{"最大相对差":>11}')
for n1, n2 in ((10, 15), (20, 30), (40, 60), (80, 120), (200, 300)):
    th_t, th_j, th_b = theory_se(n1, n2), [], []
    ts, js, bs = [], [], []
    for r in range(300):
        d = make(n1, n2, 30000 + r)
        ts.append(se_taylor_mean(d)); js.append(se_jack(d))
        bs.append(se_boot(d, B=200, seed=r)[0])
    mt, mj, mb = np.mean(ts), np.mean(js), np.mean(bs)
    spread = (max(mt, mj, mb) - min(mt, mj, mb)) / th_t * 100
    print(f'  {n1}/{n2:<6}{th_t:>9.4f}{mt:>9.4f}{mj:>9.4f}{mb:>9.4f}'
          f'{spread:>10.2f}%')

print()
print('=' * 80)
print('表4  刀切法对中位数失效:删一个点,中位数大多不变')
print('=' * 80)
print(f'  {"n1/n2":<9}{"刀切SE":>9}{"Bootstrap":>10}{"刀切唯一值":>11}'
      f'{"删除后不变的比例":>16}')
for n1, n2 in ((20, 30), (80, 120), (400, 600)):
    d = make(n1, n2, 11)
    med = lambda x: W[0]*np.median(x[0]) + W[1]*np.median(x[1])
    th0 = med(d)
    vals = []
    for h in (0, 1):
        for i in range(len(d[h])):
            dd = [d[0].copy(), d[1].copy()]
            dd[h] = np.delete(dd[h], i)
            vals.append(med(dd))
    vals = np.array(vals)
    J = len(vals)
    se_j = np.sqrt((J-1)/J*((vals-vals.mean())**2).sum())
    se_b = se_boot(d, med, B=1000, seed=11)[0]
    unchanged = np.mean(np.abs(vals - th0) < 1e-12)
    print(f'  {n1}/{n2:<6}{se_j:>9.4f}{se_b:>10.4f}{len(np.unique(np.round(vals,6))):>11}'
          f'{unchanged*100:>15.0f}%')

print()
print('=' * 80)
print('表5  计算成本(n=80/120,各跑 20 次取平均)')
print('=' * 80)
d = make(80, 120, 3)
for nm, fn in (('泰勒级数', lambda: se_taylor_mean(d)),
               ('刀切法', lambda: se_jack(d)),
               ('Bootstrap B=1000', lambda: se_boot(d, B=1000)[0])):
    t0 = time.perf_counter()
    for _ in range(20):
        fn()
    print(f'  {nm:<20}{(time.perf_counter()-t0)/20*1000:>9.2f} ms')

*数据来源:底层数据为 N(100,152) 与 N(120,202) 的模拟抽样,非真实业务数据;理论标准误由分层抽样方差公式解析计算。实验代码 calc_variance.py 与本文同目录,固定 seed=20261108,所有数字可复算。

本文讨论统计方法本身,不构成任何建模或授信决策建议。*

关注公众号:QIAN数据