5D Library › 双过程睡眠架构、慢波胶质淋巴清除与体温节律相位控制 · English

第三章 作为马尔可夫链的睡眠架构,以及一晚能告诉你什么

分期及其顺序

按标准规则判读,一夜睡眠是一串 30 秒的时段,每段标为清醒、N1、N2、N3(慢波睡眠)或 REM (Iber et al. 2007)。这个序列不是随机的。深度的 N3 集中在前半夜;REM 大约每一个半小时出现一次,其片段越接近早晨越长。两点都来自第一章的两个过程:深睡眠跟随衰减的稳态压力,REM 跟随昼夜时钟。

马尔可夫链是这种序列的自然模型:下一个时段的分期通过一张转移概率表依赖于当前分期。非齐次链允许这张表在一夜中变化。第五段程序构造了这样一条链:进入 N3 的概率随衰减的压力 s(t)=e−t/2.5hs(t) = e^{-t/2.5\,\text{h}} 变化;距上一次 REM 的非快速眼动时间满 50 分钟后才能开始 REM(一个作为状态一部分携带的超日计时器);REM 片段从约 10 分钟延长到约 35 分钟。所有速率都是示意性的;要紧的是这个结构产生了什么。

推导

# Chapter 3. Sleep architecture as a non-homogeneous Markov chain on 30-second
# epochs.
# States: W (wake), N1, N2, N3 (slow-wave sleep), R (REM). Transition
# probabilities change through the night: entry to N3 scales with homeostatic
# pressure s(t) = exp(-t / 2.5 h), so deep sleep is front-loaded; REM can
# begin only after 50 min of NREM since the last REM bout (an ultradian timer,
# kept as part of the state), and REM bouts lengthen through the night. 8
# hours in bed = 960 epochs; 2,000 simulated nights. All rates are
# illustrative; the point is what the STRUCTURE produces.
import math
import random

W, N1, N2, N3, R = range(5)
NAMES = "W N1 N2 N3 R".split()

def step(st, t, since_rem, rng):
    s = math.exp(-t / 2.5)
    u = rng.random()
    if st == W:
        return N1 if u < 0.045 else W
    if st == N1:
        if u < 0.10:
            return N2
        return W if u < 0.12 else N1
    if st == N2:
        p_n3 = 0.05 * s
        p_r = 0.0 if since_rem < 100 else 0.03 * (0.5 + t / 8)
        if u < p_n3:
            return N3
        if u < p_n3 + p_r:
            return R
        if u < p_n3 + p_r + 0.006:
            return N1
        if u < p_n3 + p_r + 0.009:
            return W
        return N2
    if st == N3:
        p_out = 0.012 + 0.05 * (1 - s)
        if u < p_out:
            return N2
        return W if u < p_out + 0.001 else N3
    # REM: bouts lengthen from about 10 to about 35 minutes
    p_end = 1.0 / (20 + 50 * t / 8)
    if u < p_end * 0.8:
        return N2
    if u < p_end:
        return W
    return R

def simulate(rng):
    st, since, seq = W, 0, []
    for e in range(960):
        t = e / 120.0
        st = step(st, t, since, rng)
        since = 0 if st == R else since + 1
        seq.append(st)
    return seq

def summary(nights):
    tot = [0] * 5
    n3_third = [0, 0, 0]
    r_third = [0, 0, 0]
    wakes, latency, cycles = [], [], []
    for seq in nights:
        on = next(i for i, s in enumerate(seq) if s != W)
        latency.append(on / 2)
        w = 0
        rem_onsets = []
        for i, s in enumerate(seq):
            tot[s] += 1
            third = min(2, i // 320)
            if s == N3:
                n3_third[third] += 1
            if s == R:
                r_third[third] += 1
            if i > on and s == W and seq[i - 1] != W:
                w += 1
            if s == R and seq[i - 1] != R:
                rem_onsets.append(i)
        wakes.append(w)
        cycles += [(b - a) / 2 for a, b in zip(rem_onsets, rem_onsets[1:])]
    n = sum(tot)
    return tot, n, n3_third, r_third, wakes, latency, cycles

if __name__ == "__main__":
    rng = random.Random(57005)
    nights = [simulate(rng) for _ in range(2000)]
    tot, n, n3t, rt, wakes, lat, cyc = summary(nights)
    print("Share of time in bed by stage")
    print(
        "   "
        + "   ".join(
            "{} {:5.1%}".format(NAMES[i], tot[i] / n) for i in range(5)
        )
    )
    print(
        "Share of all N3 falling in each third of the night:   {:.2f}  {:.2f}"
        "  {:.2f}".format(*[x / sum(n3t) for x in n3t])
    )
    print(
        "Share of all REM falling in each third of the night:  {:.2f}  {:.2f}"
        "  {:.2f}".format(*[x / sum(rt) for x in rt])
    )
    print(
        "Mean sleep-onset latency {:.1f} min; mean awakenings after onset"
        " {:.1f};\nmean interval between REM onsets {:.0f} min".format(
            sum(lat) / len(lat), sum(wakes) / len(wakes), sum(cyc) / len(cyc)
        )
    )
# Share of time in bed by stage
#    W 10.3%   N1  6.2%   N2 47.4%   N3 15.5%   R 20.6%
# Share of all N3 falling in each third of the night:   0.69  0.25  0.07
# Share of all REM falling in each third of the night:  0.14  0.36  0.50
# Mean sleep-onset latency 10.2 min; mean awakenings after onset 3.5;
# mean interval between REM onsets 92 min

仅凭结构就重现了熟悉的睡眠架构:卧床时间的 47.4% 在 N2,15.5% 在 N3,20.6% 在 REM,10.3% 清醒,入睡潜伏期 10.2 分钟,REM 片段平均每 92 分钟开始一次。它还重现了夜晚的不对称,而这一点并没有直接告诉它:全部 N3 的 0.69 落在前三分之一夜,最后三分之一只有 0.07;REM 则有 0.50 落在最后三分之一。前重的深睡眠与后重的 REM,是一个衰减过程加一个计时器的结果。

一夜的模拟睡眠图,以及 2,000 个模拟夜晚平均下来,每三分之一夜中 N3 与 REM 所占的份额。

同一个睡眠者,不同的一夜

第六段程序问了一个每个睡眠追踪器用户都该问的问题。取一个每晚生理完全相同的睡眠者——就是上面那条链,一点不改——数一数深睡眠与 REM 的分钟数。

推导

# Chapter 3. How much does one night tell you? The same sleeper, with exactly
# the same physiology every night (the p05 chain, unchanged), still produces
# different nights, because stage sequences are random. We count minutes of N3
# ("deep sleep") and of REM per night over 2,000 nights, then ask how many
# nights of averaging are needed to detect a real change of 10 minutes of N3
# (two-sided alpha 0.05, power 0.80, comparing a block of nights before with a
# block after).
import math
import random

W, N1, N2, N3, R = range(5)

def step(st, t, since_rem, rng):
    s = math.exp(-t / 2.5)
    u = rng.random()
    if st == W:
        return N1 if u < 0.045 else W
    if st == N1:
        if u < 0.10:
            return N2
        return W if u < 0.12 else N1
    if st == N2:
        p_n3 = 0.05 * s
        p_r = 0.0 if since_rem < 100 else 0.03 * (0.5 + t / 8)
        if u < p_n3:
            return N3
        if u < p_n3 + p_r:
            return R
        if u < p_n3 + p_r + 0.006:
            return N1
        if u < p_n3 + p_r + 0.009:
            return W
        return N2
    if st == N3:
        p_out = 0.012 + 0.05 * (1 - s)
        if u < p_out:
            return N2
        return W if u < p_out + 0.001 else N3
    p_end = 1.0 / (20 + 50 * t / 8)
    if u < p_end * 0.8:
        return N2
    if u < p_end:
        return W
    return R

def night(rng):
    st, since, n3, rem = W, 0, 0, 0
    for e in range(960):
        st = step(st, e / 120.0, since, rng)
        since = 0 if st == R else since + 1
        n3 += st == N3
        rem += st == R
    return n3 / 2, rem / 2

if __name__ == "__main__":
    rng = random.Random(57006)
    data = [night(rng) for _ in range(2000)]
    for k, name in ((0, "N3 (deep)"), (1, "REM")):
        v = sorted(d[k] for d in data)
        m = sum(v) / len(v)
        sd = math.sqrt(sum((x - m) ** 2 for x in v) / (len(v) - 1))
        print(
            "{:<10} mean {:5.1f} min  sd {:4.1f} min  middle 90 % {:5.1f} to"
            " {:5.1f} min".format(name, m, sd, v[100], v[1899])
        )
    sd = math.sqrt(
        sum((d[0] - sum(x[0] for x in data) / 2000) ** 2 for d in data) / 1999
    )
    n = math.ceil(2 * (1.959964 + 0.841621) ** 2 * sd ** 2 / 10.0 ** 2)
    print(
        "\nNights per block needed to detect a true 10-minute change in"
        " N3: {}".format(n)
    )
    print(
        "Share of single nights whose N3 is 10 or more minutes below this"
        "\nsleeper's own mean: {:.3f}".format(
            sum(d[0] <= sum(x[0] for x in data) / 2000 - 10 for d in data)
            / 2000
        )
    )
    print(
        "\nReading: with nothing at all changed, a sizeable share of nights"
        " look 'worse"
    )
    print(
        "by ten minutes of deep sleep'. One night's number is mostly the"
        " dice."
    )
# N3 (deep)  mean  75.5 min  sd 32.4 min  middle 90 %  24.0 to 131.0 min
# REM        mean 100.3 min  sd 38.7 min  middle 90 %  44.5 to 169.5 min
#
# Nights per block needed to detect a true 10-minute change in N3: 165
# Share of single nights whose N3 is 10 or more minutes below this
# sleeper's own mean: 0.404
#
# Reading: with nothing at all changed, a sizeable share of nights look 'worse
# by ten minutes of deep sleep'. One night's number is mostly the dice.

深睡眠平均 75.5 分钟,但标准差为 32.4 分钟,中间 90% 的夜晚从 24.0 到 131.0 分钟不等。REM 从 44.5 到 169.5 不等。睡眠者本身什么都没变。在这个模型中,0.404 的夜晚深睡眠比自己的平均值少十分钟以上——也就是说,「昨晚深睡少了十分钟」大约每五晚就有两晚会无缘无故地发生。

要检测平均深睡眠真实变化 10 分钟,比较之前一段与之后一段夜晚,每段需要 165 晚。一周的追踪看不见它。

注

这些数字可以信到什么程度。 速率恒定的马尔可夫链使每个分期的持续时间服从几何分布,这可能使夜间差异比某些真实睡眠者更大;真实夜晚还会因为真实的原因(压力、酒精、生病、晚餐过晚)而变化,进一步增大差异。所以 32.4 分钟这个数字说明的是单凭偶然能做到什么,不是一个测量值。结论的方向并不依赖于它:单晚数字中的偶然成分,相对于人们想从中读出的变化而言很大。

小结

一条只有一个衰减压力和一个超日计时器的非齐次马尔可夫链,在没有被告知这些事实的情况下,重现了一夜的架构——约 15% 深睡眠、20% REM,深睡眠集中在前(前三分之一占 0.69)、REM 集中在后(后三分之一占 0.50),周期约 92 分钟。让同一条链为一个生理从不改变的睡眠者运行,中间 90% 的夜晚深睡眠从 24.0 分钟到 131.0 分钟不等。单晚的数字大部分是偶然;检测 10 分钟的变化需要几个月,而不是几天。

参考文献

Iber, Conrad, Sonia Ancoli-Israel, Andrew L. Chesson, and Stuart F. Quan. 2007. The AASM Manual for the Scoring of Sleep and Associated Events: Rules, Terminology and Technical Specifications. American Academy of Sleep Medicine.

Fan, Y. (2026). Two-Process Sleep Architecture, Slow-Wave Glymphatic Clearance and Thermoregulatory Phase Control: Adenosine Homeostasis, Flip-Flop Switch Bistability, Core-Distal Heat Flux and Sleep-Stage Markov Chains [双过程睡眠架构、慢波胶质淋巴清除与体温节律相位控制] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090162 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).