关于「拐点提前量:每五分钟一次的模态预警与移动平均的比较」,《库普曼模态与直播拐点》给出的定量结论是什么?

结论:第五章在两百场随机示意直播上比较三条规则:模态预警的提前量中位数 3.45 分钟,平均比移动平均早 13.13 分钟,过早误报 0.055,原始曲线规则则有 0.115。

数据口径:书中的直播曲线、店铺流水与参数均为示意;全部计算由书中程序生成;本书是非个人化经营建议,现金流预报不构成融资、借贷或投资建议,书中小工具给出的每一条预警都只是内部提示,须由经营者人工判断。 第一章显示示意直播曲线的前两个模态装下 0.9285 的能量,但随机游走也有 0.872,所以方差解释不是证据,样本外预报才是;去掉 12 分钟起伏的移动平均,拐点迟到 5.89 分钟。

English version

对照数据表

下表数字由本章 Python 程序原样打印,可重新运行复现。 程序只用 Python 标准库与结论吻合的打印值: 0.055, 0.115, 13.13, 3.45

rule lead median [25%, 75%] within 5 early>15
DMD every 5 min3.45 [ -1.53, 7.96] 0.485 0.055
MA 12 + 3 falls-9.73 [-11.64, -7.75] 0.090 0.000
raw 3 falls4.38 [ -2.06, 11.33] 0.380 0.115
sessions with a signal: DMD 200, MA 200, raw 200 of 200
DMD warned at or before t*0.675
DMD predicted turn, median |error| 4.71 min, 90th pct 13.73
paired lead gain DMD - MA: mean 13.13, sd 7.58, n 200
查看完整验算程序
# Chapter 5. p51: lead time of a mode-based warning vs moving averages.
# 200 illustrative sessions (fixed seed): arrival and departure time
# constants, a 10-15 minute cycle and noise sd 20-60 drawn at random. The
# slow part turns at t* = ln(t1/t2) / (1/t2 - 1/t1). Rules: (a) DMD every
# 5 minutes on the last 40 minutes (rank 5), warn when the slow part's
# predicted turn is within 10 minutes; (b) a 12-minute trailing average
# that has fallen 3 minutes in a row; (c) the raw count falling 3 minutes
# in a row. Lead = t* minus the minute of the warning (positive = early).


import math
import cmath
import random
import statistics


def random_session(rng, sd=None, n=90):
    # 随机示意场次:进场、离场时间常数,福袋周期与噪声都在示意区间内抽取
    t1, t2 = rng.uniform(45.0, 90.0), rng.uniform(12.0, 25.0)
    amp, base = rng.uniform(3000.0, 6000.0), rng.uniform(500.0, 1200.0)
    per, cyc = rng.uniform(10.0, 15.0), rng.uniform(80.0, 200.0)
    ph = rng.uniform(0.0, 2.0 * math.pi)
    noise = rng.uniform(20.0, 60.0) if sd is None else sd
    x = [base + amp * (math.exp(-t / t1) - math.exp(-t / t2))
         + cyc * math.cos(2.0 * math.pi * t / per + ph)
         + rng.gauss(0.0, noise) for t in range(n)]
    tstar = math.log(t1 / t2) / (1.0 / t2 - 1.0 / t1)
    return x, tstar


def dot(a, b):
    return math.fsum(x * y for x, y in zip(a, b))


def matmul(a, b):
    bt = list(zip(*b))
    return [[dot(r, c) for c in bt] for r in a]


def transpose(a):
    return [list(r) for r in zip(*a)]


def svd(a):
    # 单边 Jacobi(Hestenes):两两旋转列直到正交,A = U S V^T
    m, n = len(a), len(a[0])
    if n > m:
        u, s, v = svd(transpose(a))
        return v, s, u
    cols = [[a[i][j] for i in range(m)] for j in range(n)]
    vc = [[1.0 if i == j else 0.0 for i in range(n)] for j in range(n)]
    for sweep in range(60):
        rotated = False
        for p in range(n - 1):
            for q in range(p + 1, n):
                al = dot(cols[p], cols[p])
                be = dot(cols[q], cols[q])
                ga = dot(cols[p], cols[q])
                if ga == 0.0 or abs(ga) <= 1e-15 * math.sqrt(al * be):
                    continue
                rotated = True
                ze = (be - al) / (2.0 * ga)
                t = math.copysign(1.0, ze) / (
                    abs(ze) + math.sqrt(1.0 + ze * ze))
                c = 1.0 / math.sqrt(1.0 + t * t)
                s = c * t
                cp, cq = cols[p], cols[q]
                cols[p] = [c * x - s * y for x, y in zip(cp, cq)]
                cols[q] = [s * x + c * y for x, y in zip(cp, cq)]
                vp, vq = vc[p], vc[q]
                vc[p] = [c * x - s * y for x, y in zip(vp, vq)]
                vc[q] = [s * x + c * y for x, y in zip(vp, vq)]
        if not rotated:
            break
    sig = [math.sqrt(dot(c_, c_)) for c_ in cols]
    order = sorted(range(n), key=lambda j: (-sig[j], j))
    s = [sig[j] for j in order]
    u = [[cols[j][i] / sig[j] if sig[j] > 0.0 else 0.0 for j in order]
         for i in range(m)]
    v = [[vc[j][i] for j in order] for i in range(n)]
    return u, s, v


def hankel(x, rows):
    # 延迟嵌入:第 i 行是从第 i 分钟起的一段序列
    k = len(x) - rows + 1
    return [[x[i + j] for j in range(k)] for i in range(rows)]


def dmd(x, rows, r):
    # Hankel 上的精确 DMD:X、Y 为错开一列的两块,A~ = U^T Y V S^-1
    h = hankel(x, rows)
    xs = [row[:-1] for row in h]
    ys = [row[1:] for row in h]
    u, s, v = svd(xs)
    ur = [row[:r] for row in u]
    vr = [row[:r] for row in v]
    at = matmul(matmul(transpose(ur), ys), vr)
    at = [[at[i][j] / s[j] for j in range(r)] for i in range(r)]
    return ur, at, s, h


def charpoly(a):
    # Faddeev-LeVerrier:特征多项式 z^n + c1 z^(n-1) + c2 z^(n-2) 直到 cn
    n = len(a)
    m = [[0.0] * n for _ in range(n)]
    coef = [1.0]
    for k in range(1, n + 1):
        m = matmul(a, m)
        for i in range(n):
            m[i][i] += coef[-1]
        am = matmul(a, m)
        coef.append(-math.fsum(am[i][i] for i in range(n)) / k)
    return coef


def roots(coef):
    # Durand-Kerner 同时迭代求全部复根(cmath)
    n = len(coef) - 1
    z = [cmath.rect(0.9, 0.4 + 2.0 * math.pi * k / n) for k in range(n)]

    def p(x):
        r = complex(1.0, 0.0)
        for c in coef[1:]:
            r = r * x + c
        return r
    for _ in range(800):
        new = []
        for i in range(n):
            den = complex(1.0, 0.0)
            for j in range(n):
                if j != i:
                    den *= z[i] - z[j]
            new.append(z[i] - p(z[i]) / den)
        moved = max(abs(a - b) for a, b in zip(new, z))
        z = new
        if moved < 1e-14:
            break
    return z


def eigvals(a):
    z = roots(charpoly(a))
    z = [complex(w.real, 0.0) if abs(w.imag) < 1e-12 else w for w in z]
    return sorted(z, key=lambda w: (-round(abs(w), 9), w.imag))


def csum(zs):
    zs = list(zs)
    return complex(math.fsum(z.real for z in zs),
                   math.fsum(z.imag for z in zs))


def csolve(a, b):
    # 复数高斯消元(部分主元)
    n = len(a)
    m = [list(a[i]) + [b[i]] for i in range(n)]
    for c in range(n):
        p = max(range(c, n), key=lambda i: abs(m[i][c]))
        m[c], m[p] = m[p], m[c]
        for i in range(c + 1, n):
            f = m[i][c] / m[c][c]
            for j in range(c, n + 1):
                m[i][j] -= f * m[c][j]
    xs = [0j] * n
    for i in range(n - 1, -1, -1):
        acc = csum(m[i][j] * xs[j] for j in range(i + 1, n))
        xs[i] = (m[i][n] - acc) / m[i][i]
    return xs


def amplitudes(x, lam):
    # 最小二乘求振幅:x_t = sum_k b_k lam_k^t(t 从窗口起点数)
    n = len(lam)
    vt = [[w ** t for w in lam] for t in range(len(x))]
    g = [[csum(vt[t][i].conjugate() * vt[t][j] for t in range(len(x)))
          for j in range(n)] for i in range(n)]
    rhs = [csum(vt[t][i].conjugate() * x[t] for t in range(len(x)))
           for i in range(n)]
    return csolve(g, rhs)


def slow_part(w, rows, r, min_period=30.0):
    # 拟合模态,只留周期长于 min_period 分钟、|lambda| > 0.6 的慢模态
    ur, at, s, h = dmd(w, rows, r)
    lam = eigvals(at)
    b = amplitudes(w, lam)
    keep = [k for k in range(len(lam)) if abs(lam[k]) > 0.6
            and abs(cmath.phase(lam[k])) < 2.0 * math.pi / min_period]
    return [(lam[k], b[k]) for k in keep]


def slow_value(modes, t):
    return csum(b * lam ** t for lam, b in modes).real


def predicted_peak(w, rows, r, ahead, grid=0.05):
    # 慢分量在 [0, len(w) + ahead] 上的最高点,返回相对窗口末端的分钟数
    modes = slow_part(w, rows, r)
    best, arg = None, 0.0
    steps = int(round((len(w) - 1 + ahead) / grid))
    for i in range(steps + 1):
        t = i * grid
        val = slow_value(modes, t)
        if best is None or val > best:
            best, arg = val, t
    return arg - (len(w) - 1), best, modes


def dmd_warning(x, window=40, rank=5, start=20, every=5, near=10.0,
                ahead=30):
    # 每 every 分钟拟合一次:慢分量的最高点落在未来 near 分钟以内即预警
    for tau in range(start, len(x) + 1, every):
        w = x[max(0, tau - window):tau]
        d, level, modes = predicted_peak(w, len(w) // 2, rank, ahead)
        if d <= near and d < ahead - 0.5:
            return tau, tau - 1 + d
    return None, None


def ma_turn(x, w=12, confirm=3):
    # 滑动平均连续 confirm 分钟下降才算拐头;返回能发出信号的分钟
    # (最后一个数据点的下一分钟,与 DMD 检查点同一口径)
    ma = {}
    for t in range(w - 1, len(x)):
        ma[t] = math.fsum(x[t - w + 1:t + 1]) / w
        if t >= w - 1 + confirm and all(
                ma[t - k] < ma[t - k - 1] for k in range(confirm)):
            return t + 1
    return None


def raw_turn(x, confirm=3, start=5):
    for t in range(start, len(x)):
        if all(x[t - k] < x[t - k - 1] for k in range(confirm)):
            return t + 1
    return None


def q(v, p):
    v = sorted(v)
    return v[min(len(v) - 1, int(p * len(v)))]


rng = random.Random(20261117)
dl, ml, rl, err, pair = [], [], [], [], []
for _ in range(200):
    x, ts = random_session(rng)
    tau, pred = dmd_warning(x)
    t_ma, t_raw = ma_turn(x), raw_turn(x)
    if tau is not None:
        dl.append(ts - tau)
        err.append(abs(pred - ts))
    if t_ma is not None:
        ml.append(ts - t_ma)
    if t_raw is not None:
        rl.append(ts - t_raw)
    if tau is not None and t_ma is not None:
        pair.append((ts - tau) - (ts - t_ma))
print("rule             lead median  [25%, 75%]     within 5  early>15")
for name, v in (("DMD every 5 min", dl), ("MA 12 + 3 falls", ml),
                ("raw 3 falls", rl)):
    early = len([d for d in v if d > 15.0]) / len(v)
    near = len([d for d in v if abs(d) <= 5.0]) / len(v)
    print("%-16s %8.2f    [%6.2f, %6.2f]   %8.3f  %8.3f"
          % (name, statistics.median(v), q(v, 0.25), q(v, 0.75), near,
             early))
print("sessions with a signal: DMD %d, MA %d, raw %d of 200"
      % (len(dl), len(ml), len(rl)))
print("DMD warned at or before t*: %.3f" % (len([d for d in dl if d >= 0])
                                         / len(dl)))
print("DMD predicted turn, median |error| %.2f min, 90th pct %.2f"
      % (statistics.median(err), q(err, 0.9)))
print("paired lead gain DMD - MA: mean %.2f, sd %.2f, n %d"
      % (statistics.mean(pair), statistics.stdev(pair), len(pair)))

唯一数据源与引用

范雅福(Fan, Y.). (2026). 《库普曼算子动态模态分解、现金流非线性波动线性化与直播在线曲线拐点预测母典》第 5 章「拐点提前量:每五分钟一次的模态预警与移动平均的比较」(版本 1.0.0). 5D Library. DOI 待发布

DOI 待发布 · 专著页正式发布后上线(本站暂无专著页) · 5DL-B-238 · v1.0.0 · CC-BY-NC-ND-4.0

BibTeX
@book{fan2026238,
  author    = {Fan, Yafu},
  title     = {Koopman Operators and Dynamic Mode Decomposition: Linearising Nonlinear Cash-Flow Swings and Forecasting Turning Points in Livestream Audience Curves},
  year      = {2026},
  publisher = {5D Library},
  edition   = {1.0.0},
  note      = {DOI pending}
}

本书其他章节结论