5D Library › 双过程睡眠架构、慢波胶质淋巴清除与体温节律相位控制 · English
第三章 作为马尔可夫链的睡眠架构,以及一晚能告诉你什么
分期及其顺序
按标准规则判读,一夜睡眠是一串 30 秒的时段,每段标为清醒、N1、N2、N3(慢波睡眠)或 REM (Iber et al. 2007)。这个序列不是随机的。深度的 N3 集中在前半夜;REM 大约每一个半小时出现一次,其片段越接近早晨越长。两点都来自第一章的两个过程:深睡眠跟随衰减的稳态压力,REM 跟随昼夜时钟。
马尔可夫链是这种序列的自然模型:下一个时段的分期通过一张转移概率表依赖于当前分期。非齐次链允许这张表在一夜中变化。第五段程序构造了这样一条链:进入 N3 的概率随衰减的压力 变化;距上一次 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,是一个衰减过程加一个计时器的结果。
同一个睡眠者,不同的一夜
第六段程序问了一个每个睡眠追踪器用户都该问的问题。取一个每晚生理完全相同的睡眠者——就是上面那条链,一点不改——数一数深睡眠与 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 分钟的变化需要几个月,而不是几天。
参考文献
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).