元胞自动机：从森林火灾到交通流

专栏导语 ：本专栏系统讲解数学建模的经典方法与 AI 智能方法，并打通两者之间的联系。上一篇我们用蒙特卡洛解决了"算不出的积分"------随机抽样，取平均，答案就出来了（蒙特卡洛方法：用随机抽样求解确定性问题）。这一篇再换一个角度：蒙特卡洛模拟的是"随机输入"，而元胞自动机 模拟的是"时间演化"------把世界切成一个个小格子，每个格子只看邻居、按简单规则更新自己，跑上百步之后，宏观上却会涌现出任何公式都写不出的复杂现象：森林大火的临界点、高速公路上凭空出现的堵车。它还有一条暗线------细胞自动机正是图神经网络（GNN）与多智能体强化学习的空间原型。

文章目录

一、问题引入：规则极简，结果极复杂
二、问题分析：三个必须回答的问题
三、模型假设
四、符号说明
五、模型建立
- [5.1 元胞自动机四要素](#5.1 元胞自动机四要素)
- [5.2 案例一：森林火灾与逾渗阈值](#5.2 案例一：森林火灾与逾渗阈值)
- [5.3 案例二：NaSch 交通流模型](#5.3 案例二：NaSch 交通流模型)
- [5.4 涌现：局部规则如何长出全局秩序](#5.4 涌现：局部规则如何长出全局秩序)
[六、Python 实现](#六、Python 实现)
- [6.1 森林火灾：逾渗曲线](#6.1 森林火灾：逾渗曲线)
- [6.2 NaSch 交通流：基本图与时空图](#6.2 NaSch 交通流：基本图与时空图)
- [6.3 结果可视化](#6.3 结果可视化)
七、模型评价
[八、AI 视角：从手工规则到可学习的局部交互](#八、AI 视角：从手工规则到可学习的局部交互)
- [8.1 图神经网络：把固定规则换成可学习规则](#8.1 图神经网络：把固定规则换成可学习规则)
- [8.2 多智能体强化学习：从规则到策略](#8.2 多智能体强化学习：从规则到策略)
- [8.3 神经细胞自动机：用神经网络学"生长规则"](#8.3 神经细胞自动机：用神经网络学"生长规则")
- [8.4 与扩散模型的隐秘联系](#8.4 与扩散模型的隐秘联系)
九、小结

个人主页 ：蒲公英eric

专栏传送门 ：数学建模 × AI：从经典模型到智能方法

学习方向：大数据 / 数学建模 / AI交叉领域

人生格言：建模没有终点，只有不断迭代的更优解

📌本文是专栏「数学建模 × AI：从经典模型到智能方法」的第 12 篇文章。

一、问题引入：规则极简，结果极复杂

前面的文章里，模型大多有一个"中枢"：回归有一条待拟合的直线，线性规划有一个目标函数，蒙特卡洛有一个待估的期望。但现实世界里有大量系统是去中心化的：

森林火灾：没有指挥者，每棵树只知道"我旁边有没有火"，但整片森林烧不烧得起来，却取决于一个微妙的密度临界点；
高速公路堵车：没有任何事故，车流却会凭空"幽灵堵"------一辆车轻点刹车，几十辆车之后就被放大成一段停车场；
传染病扩散：每个人只接触身边几个人，但疫情能不能压下去，取决于传染数是否越过 1。

这类问题的共同点是：个体行为极其简单，整体行为极其复杂。微分方程抓不住"局部交互"，线性模型抓不住"非线性放大"。这时需要一种全新的建模语言------

元胞自动机（Cellular Automaton, CA）：把空间切成离散的格子，时间切成离散的步，每个格子的下一状态只由自己和邻居的当前状态决定。

它是 1940 年代冯·诺依曼为研究"自我复制机器"提出的，1970 年因 Conway 的生命游戏而名声大噪，如今是交通、生态、流行病、材料科学的标准工具。

二、问题分析：三个必须回答的问题

问题 1：为什么要离散化？连续模型不行吗？

可以，但太贵。森林火灾的连续模型是反应-扩散方程，需要解 PDE；而元胞自动机把空间切成格子后，每个格子的更新规则可以写成几行代码。牺牲一点精度，换来的是"什么规则都能试"的灵活性------想加风？改一下邻居权重。想加隔离带？把某些格子设成不可燃。想加消防车？让一个特殊格子沿路走。这些在连续模型里都要重新推导方程。

问题 2：局部规则怎么设计？

这是元胞自动机的灵魂。规则必须满足三条：

局部性：只依赖邻居（否则失去 CA 的意义）；
同步性：所有格子同时更新（否则结果依赖更新顺序）；
一致性：同状态同邻居，必得同结果（可以是确定性的，也可以是带固定概率的随机规则）。

问题 3：跑出来的结果可靠吗？

这是和蒙特卡洛一脉相承的问题------单次模拟只是随机过程的一个样本 。本文所有结论都来自多次独立重复：森林火灾每个密度跑 30~50 次取平均，交通流先暖机 2000 步再测 2000 步。不重复、不报告波动的元胞自动机结果，和没固定种子的蒙特卡洛一样不可信。

三、模型假设

空间离散且均匀：森林是规则网格，公路是等长元胞，每格同质；
时间离散：以固定步长同步推进，步内不发生相互作用；
状态有限：每个元胞只有有限个离散状态（树/火/空地；有车/无车）；
规则局部且一致：更新只依赖固定邻域，所有元胞共用同一套规则；
边界明确：本文用开边界（森林）和环形边界（公路），边界条件会影响结果，必须写明。

假设 2 的"同步"最容易被忽略。如果用异步更新（比如按从左到右顺序逐个刷新），森林火灾会呈现出人为的方向性，交通流会出现虚假的单向波------CA 论文里必须写明更新方式。

四、符号说明

符号	含义	备注
n n n	网格边长	本文森林 100 × 100 100\times100 100×100
ρ \rho ρ	密度	树木密度 / 车辆密度， $0 , 1$ $0,1$ $0,1$
p p p	概率参数	火灾蔓延概率 / 随机慢化概率
s i , j t s_{i,j}^t si,jt	元胞 ( i , j ) (i,j) (i,j) 在时刻 t t t 的状态	森林：0=空地 1=树 2=火
N ( i , j ) \mathcal{N}(i,j) N(i,j)	元胞 ( i , j ) (i,j) (i,j) 的邻域	本文用 von Neumann 4-邻域
L L L	公路长度（元胞数）	本文 L = 1000 L=1000 L=1000
N N N	车辆数	环形公路上守恒
v k t v_k^t vkt	第 k k k 辆车 t t t 时刻速度	整数， 0 ≤ v ≤ v max ⁡ 0\le v\le v_{\max} 0≤v≤vmax
v max ⁡ v_{\max} vmax	最大速度	本文 5 格/步
J J J	流量	单位时间通过某截面的车辆数
ρ c \rho_c ρc	逾渗阈值	火灾从"烧不开"到"烧穿"的临界密度
ρ ∗ \rho^* ρ∗	临界密度	交通流流量最大处的密度

五、模型建立

5.1 元胞自动机四要素

任何一个 CA 都由四件事唯一确定：

元胞空间 ：规则网格（本文森林是 100 × 100 100\times100 100×100 方格，公路是 1 × 1000 1\times1000 1×1000 圆环）；
状态集合：每个格子的可能取值；
邻域结构：von Neumann 邻域（上下左右 4 格）或 Moore 邻域（加四角共 8 格）；
更新规则 ： s i , j t + 1 = ϕ ( s i , j t , { s t } N ( i , j ) ) s_{i,j}^{t+1}=\phi\big(s_{i,j}^t,\ \{s^t\}_{\mathcal{N}(i,j)}\big) si,jt+1=ϕ(si,jt, {st}N(i,j))。

四要素一写完，模型就建完了------剩下的是跑模拟、看涌现。这是 CA 与微分方程建模最大的区别：方程建模是"先写全局规律"，CA 建模是"只写局部规则，全局规律自己长出来"。

5.2 案例一：森林火灾与逾渗阈值

规则（同步更新）：

状态：0=空地，1=树，2=火；
火烧完 ： 2 → 0 2\to0 2→0（下一步变成空地）；
树着火 ： 1 → 2 1\to2 1→2，当且仅当 4 邻域内有火，且以概率 p p p 引燃；
空地不变。

初始时按密度 ρ \rho ρ 随机种树，在森林中心点一把火，看最终烧毁比例。

这里的关键问题是：密度多大时，火灾会从"烧一小片"变成"烧穿整片森林"？

这个问题在数学上叫逾渗（percolation） 。理论告诉我们：对二维方格、von Neumann 邻域、 p = 1 p=1 p=1 的情形，存在一个临界密度 ρ c ≈ 0.593 \rho_c\approx0.593 ρc≈0.593------低于它，火灾几乎必然自灭；高于它，火灾几乎必然烧穿。在临界点附近，系统行为发生质变，这就是"相变"。

5.3 案例二：NaSch 交通流模型

1992 年 Nagel 和 Schreckenberg 提出的这个模型，是交通流的"Hello World"。规则四条，按顺序对每辆车同时执行：

加速： v k ← min ⁡ ( v k + 1 , v max ⁡ ) v_k\leftarrow\min(v_k+1,\ v_{\max}) vk←min(vk+1, vmax)------司机都想开快；
减速： v k ← min ⁡ ( v k , 与前车的空格数 ) v_k\leftarrow\min(v_k,\ \text{与前车的空格数}) vk←min(vk, 与前车的空格数)------不能撞车；
随机慢化 ：以概率 p p p 令 v k ← max ⁡ ( v k − 1 , 0 ) v_k\leftarrow\max(v_k-1,\ 0) vk←max(vk−1, 0)------刹车失灵、看手机、走神；
移动：位置按新速度更新。

整个模型只有 4 行规则，却能再现真实高速公路上最诡异的现象------幽灵堵车（phantom jam） ：没有任何事故，车流会自发形成一段一段的拥堵带，并且拥堵带会向上游传播（与车流方向相反）。

第 3 条"随机慢化"是灵魂。如果 p = 0 p=0 p=0，模型是确定性的：低密度时所有车以 v max ⁡ v_{\max} vmax 匀速行驶，流量 J = v max ⁡ ρ J=v_{\max}\rho J=vmaxρ 线性上升；密度超过 1 v max ⁡ + 1 \frac{1}{v_{\max}+1} vmax+11 后，车距小于 v max ⁡ v_{\max} vmax，流量转为 J = 1 − ρ J=1-\rho J=1−ρ 线性下降------基本图是一个完美的三角形。

但只要 p > 0 p>0 p>0，情况就完全不同：随机慢化会被车流放大。一辆车减速，后车被迫减速更多，扰动不但不衰减，反而沿车流向上游传递并增强，最终自发形成稳定的拥堵带。这就是为什么现实高速公路上会"无缘无故"堵车。

5.4 涌现：局部规则如何长出全局秩序

两个案例展示了 CA 最迷人的性质------涌现（emergence）：

层级	森林火灾	交通流
微观规则	树看见邻居着火就跟着着	司机看见前车近就减速
宏观涌现	逾渗相变： ρ c ≈ 0.593 \rho_c\approx0.593 ρc≈0.593	幽灵堵车：拥堵带自发形成
临界点	密度阈值	临界密度 ρ ∗ \rho^* ρ∗
可观测	烧毁比例	流量-密度基本图

没有任何一个格子"知道"什么是相变、什么是堵车------它们只是死板地执行规则。但当数百万格子一起演化，全局规律就浮现了。这正是复杂系统科学的核心信条，也是为什么 CA 成为研究"多智能体系统"的天然语言。

六、Python 实现

6.1 森林火灾：逾渗曲线

python 复制代码

import numpy as np
from scipy.ndimage import convolve

# von Neumann 4-邻域卷积核（上下左右）
K4 = np.array([[0, 1, 0], [1, 0, 1], [0, 1, 0]])

def fire_run(n, rho, p_burn, seed):
    """跑一次森林火灾，返回烧毁比例"""
    r = np.random.default_rng(seed)
    grid = (r.random((n, n)) < rho).astype(np.int8)   # 1=树
    c = n // 2
    grid[c, c] = 2                                    # 中心点火
    n_tree = (grid == 1).sum()
    while (grid == 2).any():
        burning = (grid == 2)
        nb = convolve(burning.astype(int), K4, mode="constant", cval=0)
        ignite = (grid == 1) & (nb > 0) & (r.random((n, n)) < p_burn)
        grid = grid.copy()
        grid[burning] = 0        # 火烧完变空地
        grid[ignite] = 2         # 树被引燃
    remain = (grid == 1).sum()
    return (n_tree - remain) / n_tree if n_tree > 0 else 0.0

# 每个密度独立重复 50 次取平均
print("密度 | p=1.0 烧毁比例（50次均值±标准差）")
for rho in [0.45, 0.50, 0.55, 0.58, 0.59, 0.60, 0.62, 0.65, 0.70, 0.80]:
    fs = [fire_run(100, rho, 1.0, 11000 + 13 * k) for k in range(50)]
    print(f"{rho:.2f}  {np.mean(fs):.3f} ± {np.std(fs):.3f}")

print("\np=0.8 对照（30次均值）")
for rho in [0.60, 0.65, 0.70, 0.75, 0.80, 0.90]:
    fs = [fire_run(100, rho, 0.8, 17000 + 13 * k) for k in range(30)]
    print(f"{rho:.2f}  {np.mean(fs):.3f}")

运行结果：

复制代码

密度 | p=1.0 烧毁比例（50次均值±标准差）
0.45  0.005 ± 0.005
0.50  0.012 ± 0.017
0.55  0.059 ± 0.077
0.58  0.174 ± 0.164
0.59  0.262 ± 0.205
0.60  0.402 ± 0.266
0.62  0.703 ± 0.254
0.65  0.896 ± 0.133
0.70  0.975 ± 0.007
0.80  0.997 ± 0.001

p=0.8 对照（30次均值）
0.60  0.012
0.65  0.049
0.70  0.181
0.75  0.713
0.80  0.908
0.90  0.962

解读：

相变清晰可见 ： p = 1.0 p=1.0 p=1.0 时， ρ = 0.55 \rho=0.55 ρ=0.55 烧毁比例只有 5.9%， ρ = 0.62 \rho=0.62 ρ=0.62 跳到 70.3%， ρ = 0.70 \rho=0.70 ρ=0.70 已达 97.5%------阈值在 0.59 附近 ，与理论值 ρ c ≈ 0.593 \rho_c\approx0.593 ρc≈0.593 吻合；
临界区波动最大 ： ρ = 0.60 \rho=0.60 ρ=0.60 时标准差 0.266（一次烧 10%、另一次烧 80%），远离临界区后标准差骤降到 0.001 量级。越接近相变点，系统越不可预测------这是临界现象的普适特征；
蔓延概率决定阈值位置 ： p = 0.8 p=0.8 p=0.8 时阈值右移到 0.70~0.75。 p p p 越小，火越难点着，需要更密的森林才能烧穿。这就是为什么"及时扑灭初起火"比"控制密度"更有效------它直接降低了 p p p。

6.2 NaSch 交通流：基本图与时空图

python 复制代码

import numpy as np

def nasch(L, N, vmax, p, T_warm, T_meas, seed=0):
    """NaSch 模型：环形公路，返回平均流量"""
    r = np.random.default_rng(seed)
    pos = np.sort(r.choice(L, N, replace=False))   # N 辆车随机放置
    v = r.integers(0, vmax + 1, N)
    flow = 0.0
    for t in range(T_warm + T_meas):
        v = np.minimum(v + 1, vmax)                          # 1.加速
        gap = (np.roll(pos, -1) - pos - 1) % L               # 与前车空格数
        v = np.minimum(v, gap)                               # 2.减速
        slow = r.random(N) < p
        v = np.where(slow, np.maximum(v - 1, 0), v)          # 3.随机慢化
        pos = (pos + v) % L                                  # 4.移动
        if t >= T_warm:
            flow += v.sum() / L
    return flow / T_meas

# 基本图：流量随密度变化
print("密度rho | 流量J")
for N in [30, 50, 70, 80, 90, 100, 110, 120, 130, 150,
          200, 300, 400, 500, 600, 700, 800, 900]:
    J = nasch(1000, N, 5, 0.3, 2000, 2000, seed=17)
    print(f"{N/1000:.2f}  {J:.4f}")

# 时空图数据
rng = np.random.default_rng(3)
L, N, vmax, p, T = 200, 50, 5, 0.3, 120
pos = np.sort(rng.choice(L, N, replace=False))
v = np.zeros(N, dtype=int)
img = np.zeros((T, L), dtype=np.int8)
for t in range(T):
    img[t, pos] = 1
    v = np.minimum(v + 1, vmax)
    gap = (np.roll(pos, -1) - pos - 1) % L
    v = np.minimum(v, gap)
    slow = rng.random(N) < p
    v = np.where(slow, np.maximum(v - 1, 0), v)
    pos = (pos + v) % L
print(f"\n时空图占用率={img.mean():.3f}（理论 {N/L}）")

运行结果：

复制代码

密度rho | 流量J
0.03  0.1407
0.05  0.2340
0.07  0.3268
0.08  0.3732
0.09  0.4185
0.10  0.4614
0.11  0.4717
0.12  0.4615
0.13  0.4666
0.15  0.4614
0.20  0.4379
0.30  0.3939
0.40  0.3447
0.50  0.2965
0.60  0.2438
0.70  0.1884
0.80  0.1298
0.90  0.0677

时空图占用率=0.250（理论 0.25）

解读：

流量先升后降，峰值在 ρ ∗ ≈ 0.11 \rho^*\approx0.11 ρ∗≈0.11：低密度时车少路空，加车流量上升；超过临界密度后，车间距小于 v max ⁡ v_{\max} vmax，随机慢化开始放大扰动，流量掉头向下------密度不是越大越好，路不是越满越好；
p = 0.3 p=0.3 p=0.3 时最大流量 0.47，远低于 p = 0 p=0 p=0 理论峰值 0.83------随机慢化把通行能力砍掉了近一半。这就是为什么真实高速公路的实际通行能力远低于设计值；
时空图占用率精确等于密度，说明模拟实现正确。

6.3 结果可视化

python 复制代码

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from matplotlib.patches import Patch

plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False

# ---- 数据（与 6.1/6.2 相同的种子重算，保证可复现）----
from scipy.ndimage import convolve
K4 = np.array([[0, 1, 0], [1, 0, 1], [0, 1, 0]])

def fire_run(n, rho, p_burn, seed):
    r = np.random.default_rng(seed)
    grid = (r.random((n, n)) < rho).astype(np.int8)
    c = n // 2
    grid[c, c] = 2
    n_tree = (grid == 1).sum()
    while (grid == 2).any():
        burning = (grid == 2)
        nb = convolve(burning.astype(int), K4, mode="constant", cval=0)
        ignite = (grid == 1) & (nb > 0) & (r.random((n, n)) < p_burn)
        grid = grid.copy()
        grid[burning] = 0
        grid[ignite] = 2
    remain = (grid == 1).sum()
    return (n_tree - remain) / n_tree if n_tree > 0 else 0.0, grid

rhos1 = [0.45, 0.50, 0.55, 0.58, 0.59, 0.60, 0.62, 0.65, 0.70, 0.80]
m1 = [np.mean([fire_run(100, r0, 1.0, 11000 + 13 * k)[0] for k in range(50)]) for r0 in rhos1]
rhos2 = [0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95]
m2 = [np.mean([fire_run(100, r0, 0.8, 17000 + 13 * k)[0] for k in range(30)]) for r0 in rhos2]

# 火灾快照
r = np.random.default_rng(42)
orig = (r.random((100, 100)) < 0.65)
frac, final = fire_run(100, 0.65, 1.0, 42)
disp = np.full((100, 100), 0)
disp[orig & (final == 1)] = 1   # 幸存
disp[orig & (final == 0)] = 2   # 烧毁

# NaSch 数据（用 6.2 的输出重算，或直接读入）
Ns = [30, 50, 70, 80, 90, 100, 110, 120, 130, 150, 200, 300, 400, 500, 600, 700, 800, 900]
rhos_n = np.array(Ns) / 1000

def nasch(L, N, vmax, p, T_warm, T_meas, seed=0):
    r = np.random.default_rng(seed)
    pos = np.sort(r.choice(L, N, replace=False))
    v = r.integers(0, vmax + 1, N)
    flow = 0.0
    for t in range(T_warm + T_meas):
        v = np.minimum(v + 1, vmax)
        gap = (np.roll(pos, -1) - pos - 1) % L
        v = np.minimum(v, gap)
        slow = r.random(N) < p
        v = np.where(slow, np.maximum(v - 1, 0), v)
        pos = (pos + v) % L
        if t >= T_warm:
            flow += v.sum() / L
    return flow / T_meas

Js = [nasch(1000, N, 5, 0.3, 2000, 2000, seed=17) for N in Ns]

# 时空图（与 6.2 相同的参数，重算一遍，保证本段可独立运行）
rng2 = np.random.default_rng(3)
L2, N2, vmax2, p2, T2 = 200, 50, 5, 0.3, 120
pos2 = np.sort(rng2.choice(L2, N2, replace=False))
v2 = np.zeros(N2, dtype=int)
img = np.zeros((T2, L2), dtype=np.int8)
for t in range(T2):
    img[t, pos2] = 1
    v2 = np.minimum(v2 + 1, vmax2)
    gap2 = (np.roll(pos2, -1) - pos2 - 1) % L2
    v2 = np.minimum(v2, gap2)
    slow2 = rng2.random(N2) < p2
    v2 = np.where(slow2, np.maximum(v2 - 1, 0), v2)
    pos2 = (pos2 + v2) % L2

# ---- 绘图 ----
fig, ax = plt.subplots(2, 2, figsize=(13, 10))

a = ax[0, 0]
a.plot(rhos1, m1, 'o-', color='#4C72B0', lw=2, ms=5, label='蔓延概率 p=1.0')
a.plot(rhos2, m2, 's-', color='#DD8452', lw=2, ms=5, label='蔓延概率 p=0.8')
a.axvline(0.5927, color='#C44E52', ls='--', lw=1.5, label=r'理论逾渗阈值 $\rho_c\approx0.593$')
a.set_xlabel(r'树木密度 $\rho$')
a.set_ylabel('烧毁比例')
a.set_title('(a) 森林火灾：密度超过阈值，火灾"突然"失控')
a.legend(fontsize=9)
a.grid(alpha=0.3)

b = ax[0, 1]
cmap = ListedColormap(['#F2F2F2', '#55A868', '#C44E52'])
b.imshow(disp, cmap=cmap, vmin=0, vmax=2, interpolation='nearest')
b.set_title(f'(b) 一次模拟的灾后图（$\\rho$=0.65，烧毁 {frac*100:.1f}%）')
b.set_xticks([]); b.set_yticks([])
b.legend(handles=[Patch(color='#F2F2F2', label='空地'), Patch(color='#55A868', label='幸存树木'),
                  Patch(color='#C44E52', label='烧毁区域')], fontsize=9, loc='upper right')

c = ax[1, 0]
c.plot(rhos_n, Js, 'o-', color='#4C72B0', lw=2, ms=5, label='NaSch 模拟（p=0.3）')
rr = np.linspace(0.005, 1, 200)
c.plot(rr, np.minimum(5 * rr, 1 - rr), '--', color='#DD8452', lw=1.5, label='无随机慢化 p=0（理论）')
c.axvline(0.11, color='#C44E52', ls=':', lw=1.5, label=r'临界密度 $\rho^*\approx0.11$')
c.set_xlabel(r'车辆密度 $\rho$（辆/格）')
c.set_ylabel('流量 J（辆/步）')
c.set_title('(c) 交通流基本图：密度不是越大越好')
c.legend(fontsize=9)
c.grid(alpha=0.3)
c.set_xlim(0, 0.95)

d = ax[1, 1]
d.imshow(img, cmap='Greys', aspect='auto', origin='upper', interpolation='nearest')
d.set_xlabel('位置（格）')
d.set_ylabel('时间（步）')
d.set_title(r'(d) 时空图（$\rho$=0.25）：幽灵堵车带向上游传播')

plt.tight_layout()
plt.savefig('11-元胞自动机结果图.png', dpi=150, bbox_inches='tight')
plt.show()

四张图怎么读：

(a) 逾渗曲线 ： p = 1.0 p=1.0 p=1.0 的曲线在 ρ c ≈ 0.593 \rho_c\approx0.593 ρc≈0.593 附近陡然竖起------这就是相变。 p = 0.8 p=0.8 p=0.8 的曲线整体右移，阈值推到 0.70~0.75；
(b) 灾后图 ： ρ = 0.65 \rho=0.65 ρ=0.65 时一次模拟烧掉 94% 的树（红色），幸存的树（绿色）呈破碎的小簇------它们是被空地"隔离带"意外保护下来的；
© 基本图 ：蓝线是 p = 0.3 p=0.3 p=0.3 的模拟结果，橙色虚线是 p = 0 p=0 p=0 的三角形理论。随机慢化把整个三角形"压低并磨圆"------这是真实高速公路通行能力低于设计值的微观解释；
(d) 时空图 ：每个黑点是一辆车，纵轴向下是时间前进。车流整体向右（下游）运动，但那些粗黑的斜带是拥堵带，它们向左上方倾斜------即向上游传播。一辆车在某处刹了一下，几分钟后，几公里外的车会无缘无故停下。这就是"幽灵堵车"。

七、模型评价

优点：

建模成本极低：规则只有几行，却能源源不断产生宏观现象------把"不会推公式"的门槛降到了"会写 if 语句"；
天然并行：所有格子同步更新，每个格子的计算互不依赖，GPU 上可轻松跑到千万级网格；
可视化友好：模拟过程直接就是动画/图像，论文里放一张时空图胜过三页公式；
捕捉非连续现象：相变、激波、涌现------这些微分方程难以处理的"突变"，在 CA 里是自然产物；
规则即假设：每条规则都对应一个可讨论的物理/行为假设（"司机以 0.3 概率慢化"），模型透明可解释。

局限：

结果依赖离散化：网格形状（方格/六边形）、邻域选择（von Neumann/Moore）、边界条件都会改变结果------同一问题换套离散方案，结论可能不同；
参数标定困难 ： p = 0.3 p=0.3 p=0.3 是拍脑袋还是拟合数据？CA 的参数很难从第一性原理推出，通常需要反演；
缺乏解析理论 ：除了极少数特例，CA 的全局行为无法解析预测，只能靠大量数值实验------"跑出来的规律"说服力天然弱于"推出来的定理"；
时间和空间尺度绑定：一格是 5 米还是 10 米、一步是 1 秒还是 0.1 秒，直接影响规则设计------尺度选择本身就是建模决策；
同步更新的副作用：同步性简化了分析，但也可能引入真实系统没有的人为周期性。

常见问题：

Q1：元胞自动机和蒙特卡洛有什么区别？

蒙特卡洛是用随机性估计一个确定的量 （积分、期望、分位数），模拟的是"抽样"；元胞自动机是用局部规则演化一个动力系统 ，模拟的是"时间"。两者可以结合------本文森林火灾的着火概率 p p p 就是随机规则，本质上是"带随机规则的 CA"，每个密度还要跑 50 次取平均，这就是蒙特卡洛的思想。CA 管"怎么演化"，MC 管"怎么统计"。

Q2：von Neumann 邻域和 Moore 邻域怎么选？

von Neumann 是上下左右 4 格，Moore 再加 4 个对角共 8 格。物理上"接触才能传递"的过程 （热传导、机械波）用 von Neumann 更合理；"看得见就算"的过程 （视线、气味、病害孢子）用 Moore 更合理。敏感性上：Moore 邻域更大，火灾更容易蔓延，逾渗阈值更低（约 0.407）。本文用 von Neumann 是为了对齐 ρ c ≈ 0.593 \rho_c\approx0.593 ρc≈0.593 这个经典结果。论文里必须写明邻域选择并讨论其影响。

Q3：交通流模拟为什么要"暖机"？

初始状态是随机撒车，车头间距分布极不均匀。前几百步系统处于"调整期"，流量会偏高或偏低。暖机 2000 步让系统进入稳态------此时统计的流量才是"这条路的真实通行能力"，而不是"初始分布的遗产"。这和马尔可夫链蒙特卡洛的 burn-in 是同一思想。

Q4：临界密度 ρ ∗ \rho^* ρ∗ 是严格算出来的吗？

不是。和森林火灾的 ρ c \rho_c ρc 一样， ρ ∗ \rho^* ρ∗ 也只能通过大量模拟逼近。本文从 0.03 扫到 0.90，峰值出现在 0.11 附近，但精确位置依赖 p p p、 v max ⁡ v_{\max} vmax、 L L L。CA 模型的"临界点"都是数值意义上的，不是解析解。

Q5：CA 能预测真实森林火灾吗？

定性可以，定量极难。真实火灾还受风向、坡度、湿度、树种差异、扑救影响------本文模型是"裸版"，用来展示相变这个概念。要预测真实火场，需要把规则复杂化（风向加权邻域、湿度依赖的 p p p、动态边界），模型会迅速变成"专门为某个地区定制的仿真软件"。这是 CA 的两难：规则简单了不现实，规则复杂了不通用。

Q6：CA 和元胞神经网络、图神经网络什么关系？

惊人的近：CA 就是在规则网格上做消息传递 ------每个格子聚合邻居信息，更新自己。这正是图神经网络（GNN）的核心操作，只是 GNN 把"固定规则"换成了"可学习的神经网络"。可以说：CA 是权重手工设定的 GNN，GNN 是规则可学习的 CA。多智能体强化学习里的智能体通信，本质上也是同一种"局部交互→全局决策"的范式。

八、AI 视角：从手工规则到可学习的局部交互

元胞自动机看起来像"玩具模型"，但它的思想骨架贯穿了现代 AI 的三条主线。

8.1 图神经网络：把固定规则换成可学习规则

CA 的更新是

s i t + 1 = ϕ ( s i t , ∑ j ∈ N ( i ) s j t ) s_i^{t+1}=\phi\Big(s_i^t,\ \sum_{j\in\mathcal{N}(i)}s_j^t\Big) sit+1=ϕ(sit, j∈N(i)∑sjt)

GNN 的一层是

h i ( l + 1 ) = ϕ ( h i ( l ) , ∑ j ∈ N ( i ) h j ( l ) W ) h_i^{(l+1)}=\phi\Big(h_i^{(l)},\ \sum_{j\in\mathcal{N}(i)}h_j^{(l)}W\Big) hi(l+1)=ϕ(hi(l), j∈N(i)∑hj(l)W)

形式几乎一样 ------都是"聚合邻居、更新自己"。区别只在 ϕ \phi ϕ：CA 里是手工写的 if 语句，GNN 里是可学习的神经网络。如果让 GNN 在 CA 生成的数据上训练，它能重新"发现"火灾蔓延规则；反过来，CA 是理解 GNN 消息传递机制的最好教具。

8.2 多智能体强化学习：从规则到策略

NaSch 模型里每辆车的"规则"是固定的（加速、减速、慢化、移动）。如果把规则换成可学习的策略 π ( a i ∣ s i ) \pi(a_i|s_i) π(ai∣si)------每辆车根据局部观察自己决定动作------就得到了多智能体强化学习（MARL）。堵车带会不会形成、形成多快，取决于所有智能体策略的联合。这就是为什么 MARL 研究者用交通流做标准测试床。

8.3 神经细胞自动机：用神经网络学"生长规则"

2020 年 Google 的 Neural Cellular Automata（NCA） 把 CA 推向了一个新高度：让神经网络学习更新规则 ϕ θ \phi_\theta ϕθ，从一个单细胞"长"出一张完整图像（比如一只蜥蜴），而且被剪掉一半后还能自我再生 。这证明了：复杂的全局形态可以从简单的局部学习规则中涌现------这既是发育生物学的计算模型，也是生成式 AI 的一条少有人走的路。

8.4 与扩散模型的隐秘联系

本文第 10 篇讲的扩散模型，生成过程是"从噪声出发、逐步去噪"。如果把每个像素看成一个元胞，去噪网络看成更新规则，那么扩散模型的生成过程就是一个随机场上的（连续状态）元胞自动机 ------每个像素只看邻域信息，迭代更新，最终涌现出全局图像结构。CA 与扩散模型共享同一个信念：全局复杂性可以归约为局部简单规则的迭代。

本文概念	AI 里的对应
局部更新规则	GNN 消息传递、NCA 生长规则
同步演化	扩散模型迭代去噪、Transformer 层叠
随机规则（慢化概率）	随机策略、dropout、探索噪声
涌现 / 相变	大模型能力涌现、Grokking
多格子去中心化	多智能体系统、群体智能

九、小结

四要素：元胞空间 + 状态集合 + 邻域结构 + 更新规则，一个 CA 就建完了；
森林火灾 ：von Neumann 邻域、 p = 1.0 p=1.0 p=1.0 时逾渗阈值 ρ c ≈ 0.593 \rho_c\approx0.593 ρc≈0.593，密度从 0.55 到 0.62，烧毁比例从 6% 跳到 70%------相变是 CA 最具标志性的涌现现象；
临界区不可预测 ：越接近阈值，单次模拟结果波动越大（ ρ = 0.60 \rho=0.60 ρ=0.60 时标准差 0.27），必须多次重复并报告波动；
NaSch 交通流 ：4 条规则再现幽灵堵车------拥堵带自发形成并向上游传播；随机慢化 p = 0.3 p=0.3 p=0.3 使最大流量从理论 0.83 降到 0.47，临界密度 ρ ∗ ≈ 0.11 \rho^*\approx0.11 ρ∗≈0.11；
密度悖论：交通流基本图证明"路上车越多，通过的车反而可能越少"------为匝道控制、限速管理提供了微观依据；
方法论纪律：写明邻域/边界/更新方式，暖机到稳态再统计，多次重复报告均值±标准差------CA 论文的审稿人最常挑的就是这三点；
AI 伏笔 ：CA 的"局部规则→全局涌现"正是 GNN 消息传递、MARL 多智能体交互、NCA 形态发生、扩散模型迭代生成的共同骨架------局部简单规则的迭代，是复杂智能的基本配方。

下一篇暂时跳出仿真类模型，回到聚类：当数据没有标签时，如何让相似的样本自动聚在一起------K-Means 与 GMM：从硬划分到软划分，并接上 EM 算法这条通往"含隐变量模型"的暗线。

📌 本文是专栏「数学建模 × AI：从经典模型到智能方法」的第 12 篇文章。

上一篇回顾 ：蒙特卡洛方法：用随机抽样求解确定性问题
下一篇预告 ：K-Means 与 GMM：从硬划分到软划分------无标签数据的自动聚类。

👉 点击订阅专栏，第一时间收到更新通知！**

如果你在阅读过程中有任何疑问，欢迎在评论区留言交流。😊