返回专栏
· 23 分钟阅读

Continuous Batching 连续批处理:大模型推理的动态调度机制


一、什么是 Continuous Batching?

Continuous Batching,中文通常称为连续批处理或连续批次调度,是大模型推理服务中一种动态批处理技术。

它的核心思想是:不再要求一个 Batch 中的所有请求同时开始、同时结束,而是允许请求根据各自的执行进度动态加入和退出。

传统批处理通常采用固定批次:

  • 一批请求同时进入模型。
  • 所有请求共同执行推理。
  • 等待这一批请求全部完成。
  • 才开始处理下一批请求。

Continuous Batching 则不同:

  • 已完成的请求立即退出当前批次。
  • 新到达的请求可以在合适的调度边界加入。
  • 未完成的请求继续执行 Decode。
  • 调度器根据 GPU 资源和请求状态动态调整批次。

这种机制尤其适合 Transformer 自回归生成任务,因为不同请求的输入长度、输出长度和执行时间往往存在明显差异。

1.1 为什么需要连续批处理?

假设有 4 个请求:

请求 输入长度 输出长度
A 500 Token 100 Token
B 300 Token 20 Token
C 800 Token 200 Token
D 200 Token 50 Token

如果采用传统固定批处理,4 个请求一起执行,B 可能很早就生成完毕,但仍然需要等待 A、C、D 完成。

这会带来两个问题:

  1. 已完成请求占据批次位置,不能及时释放执行资源。
  2. 新到达的请求必须等待当前批次结束,无法及时利用 GPU 空闲能力。

Continuous Batching 可以让 B 完成后立即退出,并让新的请求进入调度流程。

1.2 核心区别

对比维度 Static Batching Continuous Batching
批次组成 固定 动态变化
请求加入 通常在批次开始前 可在调度边界加入
请求退出 通常等待整个批次结束 单个请求完成后退出
批次生命周期 整体一致 每个请求独立
GPU 利用率 容易受到长请求影响 通常更高
调度复杂度 较低 较高
适用场景 离线批量计算 在线生成服务

需要注意:Continuous Batching 并不意味着 GPU 上的所有请求可以在任意时刻打断正在执行的 CUDA Kernel。

实际系统通常在 Prefill 和 Decode 等调度迭代边界进行请求加入、退出和批次重组。


二、传统 Static Batching 的问题

理解 Continuous Batching,需要先理解传统批处理为什么会浪费 GPU 资源。

2.1 固定批次执行机制

传统 Static Batching 将一组请求组织成固定 Batch。

例如,一个 Batch 包含 A、B、C 三个请求:

flowchart TD
    A["接收请求 A、B、C"] --> B["组成固定 Batch"]
    B --> C["统一执行 Prefill"]
    C --> D["统一执行 Decode"]
    D --> E{"所有请求是否完成"}
    E -->|"否"| D
    E -->|"是"| F["释放整个 Batch"]
    F --> G["接收下一批请求"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976

问题在于,不同请求的生成长度通常不同。

假设:

  • A 需要生成 100 Token。
  • B 需要生成 20 Token。
  • C 需要生成 60 Token。

当 B 生成完毕时,A 和 C 仍然需要继续执行。

如果批次必须整体结束,B 对应的计算位置就无法及时用于处理新请求。

2.2 Padding 带来的计算浪费

为了将不同长度的输入组织成统一张量,传统批处理经常需要 Padding。

例如:

请求 A:Hello world
请求 B:Hello
请求 C:Hello world today

经过 Padding:

请求 A:[Hello, world, PAD]
请求 B:[Hello, PAD, PAD]
请求 C:[Hello, world, today]

模型需要处理统一形状的输入张量。

Padding 会引入无效位置,增加部分计算和内存访问开销。

对于自回归生成任务,还可能出现输出长度不一致的问题。

2.3 Head-of-Line Blocking

Head-of-Line Blocking,队头阻塞,是固定批处理中的典型问题。

一个较长请求可能拖慢整个批次的资源释放。

例如:

请求 A:████████████████████
请求 B:████
请求 C:██████████

B 已经完成,但如果批次需要等待 A 和 C,B 的资源就不能立即被新请求利用。

其本质是:

批次生命周期被最长请求决定,而不是由每个请求自己的生命周期决定。

2.4 GPU 利用率下降

在线推理服务中的请求到达时间并不规律。

如果系统必须等待足够多的请求才能组成一个新 Batch,可能出现:

  • GPU 等待请求积累。
  • 部分请求完成后 GPU 计算资源利用不足。
  • 长请求拖延短请求。
  • 突发流量导致排队时间增加。

因此,固定批处理难以充分适应在线服务的动态负载。


三、Continuous Batching 的核心工作原理

Continuous Batching 的核心是将 Batch 从一个固定执行单元,转变为一个动态调度单元。

3.1 请求独立管理

每个请求拥有独立的执行状态。

常见状态包括:

状态 含义
Waiting 等待进入执行队列
Running 正在执行模型推理
Prefill 正在处理输入 Token
Decode 正在逐 Token 生成
Finished 已完成生成
Aborted 被取消或终止
Preempted 因资源不足被暂时抢占

实际推理引擎可能使用不同的状态名称,但核心思想相同。

请求不再依赖整个 Batch 的生命周期,而是独立推进。

3.2 动态加入与退出

假设当前 Batch 有三个请求:

Batch = [A, B, C]

当 B 完成后:

Batch = [A, C]

此时新请求 D 到达:

Batch = [A, C, D]

整个过程不需要等待 A 和 C 全部结束。

动态变化过程如下:

flowchart TD
    A["请求进入 Waiting 队列"] --> B["Scheduler 选择可执行请求"]
    B --> C["组成当前 Batch"]
    C --> D["执行一次模型推理迭代"]
    D --> E{"请求是否完成"}
    E -->|"是"| F["移出当前 Batch"]
    E -->|"否"| G["保留请求继续执行"]
    F --> H["释放对应执行资源"]
    G --> I["保留 KV Cache"]
    H --> J["重新评估调度条件"]
    I --> J
    J --> K{"是否有新请求可加入"}
    K -->|"是"| L["选择新请求加入"]
    K -->|"否"| M["继续当前请求"]
    L --> C
    M --> D

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style K fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style M fill:#EAF3EC,stroke:#83A995,color:#315D49

3.3 迭代级调度

Continuous Batching 通常以模型推理迭代为调度单位。

在 Decode 阶段,一次迭代通常为当前活跃请求生成一个 Token。

例如:

第 1 次迭代:A、B、C
第 2 次迭代:A、B、C
第 3 次迭代:A、C、D
第 4 次迭代:A、C、D
第 5 次迭代:C、D、E

这里:

  • B 在第 2 次迭代后完成。
  • D 在第 3 次迭代加入。
  • A 在第 4 次迭代后完成。
  • E 在第 5 次迭代加入。

每一次迭代都可以根据请求状态重新组织批次。

这就是 Continuous Batching 中 Continuous 的含义。

它不是一次性构建固定 Batch,而是让批次随着请求生命周期不断变化。


四、Continuous Batching 与 Prefill、Decode 的关系

Continuous Batching 与 Transformer 的 Prefill、Decode 两阶段密切相关。

4.1 Prefill 阶段

Prefill 负责处理用户输入的全部 Prompt Token。

例如:

用户输入:
请解释什么是 Transformer,以及它的核心结构。

Tokenizer:
[T1, T2, T3, ..., T100]

模型将这些 Token 一次性输入 Transformer,计算各层 Attention 和 FFN,并生成对应的 KV Cache。

Prefill 的特点:

  • 输入 Token 数量可能较大。
  • 计算密集度较高。
  • 可以利用矩阵并行计算。
  • 请求之间的 Prompt 长度可能差异很大。

4.2 Decode 阶段

Decode 负责逐 Token 生成输出。

例如:

第 1 次:Transformer
第 2 次:是一种
第 3 次:基于
第 4 次:注意力机制

每次 Decode 通常只输入当前新生成的 Token,并读取之前保存的 KV Cache。

Decode 的特点:

  • 通常每个请求每轮生成一个 Token。
  • 需要持续访问历史 KV Cache。
  • 对显存带宽和内存访问效率较敏感。
  • 不同请求的生成长度存在差异。

4.3 两阶段的调度差异

维度 Prefill Decode
输入 整段 Prompt 当前 Token
输出 建立初始 KV Cache 新生成 Token
计算特征 偏计算密集 通常偏内存带宽受限
序列长度 一次处理多个输入 Token 每轮处理少量 Token
调度难点 长 Prompt 占用大量计算资源 多请求持续竞争 KV Cache
常见优化 Chunked Prefill Continuous Batching

Continuous Batching 最典型的应用场景是 Decode 阶段,但现代推理引擎通常还会将 Prefill 纳入统一调度。

4.4 Prefill 与 Decode 混合调度

在线服务中,可能同时存在:

  • 已经进入 Decode 的请求。
  • 刚到达、等待 Prefill 的请求。
  • 正在进行长 Prompt Prefill 的请求。

如果 Prefill 一次占用过多 GPU 计算资源,就可能影响 Decode 请求的 Token 生成速度。

因此,推理引擎需要在两种工作负载之间进行平衡。

典型方法包括:

  1. 限制单轮 Prefill 的 Token 数量。
  2. 将长 Prompt 拆分为多个 Chunk。
  3. 控制 Decode 请求的调度优先级。
  4. 根据剩余 GPU 计算预算动态选择任务。

五、Continuous Batching 的核心组件

一个完整的 Continuous Batching 系统通常包含以下组件。

5.1 Request Queue:请求队列

负责接收尚未执行的请求。

请求通常按照到达时间、优先级、服务等级或调度策略排列。

常见队列:

  • Waiting Queue:等待调度的请求。
  • Running Queue:正在执行的请求。
  • Preempted Queue:被抢占后等待恢复的请求。

请求队列负责管理请求生命周期,但不直接执行模型计算。

5.2 Scheduler:调度器

Scheduler 是 Continuous Batching 的核心。

主要职责包括:

  • 选择哪些请求进入当前迭代。
  • 判断是否有足够的 KV Cache Block。
  • 控制 Prefill 和 Decode 的资源分配。
  • 处理请求完成和取消。
  • 处理显存不足时的抢占。
  • 控制最大并发序列数和批次 Token 数。

调度器不仅需要考虑 GPU 计算能力,还需要考虑 KV Cache 的可用容量。

5.3 Model Runner:模型执行器

负责执行模型计算。

典型职责:

  • 准备输入 Token。
  • 构造批次张量。
  • 准备位置编码和 Attention 元数据。
  • 执行 Transformer 层。
  • 调用 Attention Kernel。
  • 计算 Logits。
  • 执行 Token Sampling。

5.4 KV Cache Manager:缓存管理器

负责管理每个请求的历史 Key、Value 状态。

在 Continuous Batching 中,请求加入和退出频繁发生,因此 KV Cache 必须支持动态分配和释放。

主要职责:

  • 为新请求分配 KV Cache。
  • 为 Decode 请求扩展缓存。
  • 为完成请求释放缓存。
  • 管理共享前缀缓存。
  • 处理显存不足时的资源回收。

5.5 Sampler:采样器

负责根据模型输出的 Logits 选择下一个 Token。

常见策略:

  • Greedy Sampling。
  • Temperature Sampling。
  • Top-K Sampling。
  • Top-P Sampling。
  • Repetition Penalty。

Sampler 生成新 Token 后,推理引擎会更新请求状态,并决定是否继续执行。

5.6 Detokenizer:文本解码器

负责将模型生成的 Token 转换为用户可读文本。

在流式服务中,Detokenizer 会持续处理新 Token,并通过 API 将生成结果发送给客户端。


六、Continuous Batching 与 KV Cache 管理

Continuous Batching 能否高效运行,很大程度上取决于 KV Cache 的管理能力。

6.1 为什么 KV Cache 是关键?

在自回归生成过程中,模型需要保留历史 Token 的 Key 和 Value。

对于一个请求,其 KV Cache 大小可以近似表示为:

M_{KV} = 2 \times L \times S \times H_{kv} \times D_h \times B

其中:

  • L:Transformer 层数。
  • S:当前缓存 Token 数量。
  • H_{kv}:KV Head 数量。
  • D_h:每个 Head 的维度。
  • B:每个元素的字节数。
  • 2:分别表示 Key 和 Value。

随着 Decode 持续进行,序列长度增加,KV Cache 也会持续增长。

因此,Batch 中的请求数量并不是唯一的资源限制。

一个 Batch 即使请求数不多,也可能因为长上下文而占用大量显存。

6.2 动态分配 KV Cache

传统方式可能为每个请求预先分配一块连续显存。

这会产生两个问题:

  • 需要提前估算最大序列长度。
  • 请求实际长度不同,容易产生显存浪费。

现代推理引擎通常使用 PagedAttention 一类分页机制管理 KV Cache。

将 KV Cache 划分为固定大小的 Block:

请求 A:Block 1 → Block 4 → Block 7
请求 B:Block 2 → Block 5
请求 C:Block 3 → Block 6 → Block 8

每个请求通过 Block Table 记录逻辑位置与物理 Block 的映射。

请求需要更多缓存时,再分配新的 Block。

请求完成时,释放其占用的 Block。

6.3 请求完成后的资源释放

例如当前 Batch:

A:KV Block 1、4
B:KV Block 2、5
C:KV Block 3、6

当 B 完成后:

A:KV Block 1、4
C:KV Block 3、6

释放:
KV Block 2、5

释放后的 Block 可以供新请求使用。

这使得连续批处理不仅能够动态管理计算任务,也能够动态管理显存资源。

6.4 KV Cache 与 Batch Size 的关系

传统 Batch Size 主要描述批次中的请求数量。

但在大模型推理中,真正重要的是整个 Batch 的资源占用。

例如:

Batch 请求数 平均上下文长度 KV Cache 压力
A 16 512 Token 较低
B 16 8192 Token 较高
C 32 2048 Token 中高
D 8 32768 Token 很高

因此,调度器不能只根据请求数量判断是否还能加入新请求。

还必须检查:

  • 当前剩余 KV Cache Block。
  • 新请求的 Prompt 长度。
  • 预计生成长度。
  • 最大上下文长度。
  • 当前请求的缓存增长速度。

七、Continuous Batching 的调度策略

Continuous Batching 不只是动态增删请求,还需要合理决定每一轮执行哪些请求。

7.1 FCFS:先来先服务

FCFS(First Come First Served)按照请求到达顺序进行调度。

优点:

  • 实现简单。
  • 调度开销低。
  • 相对容易保证请求顺序公平。

缺点:

  • 长 Prompt 可能阻塞短 Prompt。
  • 长请求可能影响短请求的响应时间。
  • 不容易兼顾不同优先级的业务。

7.2 Priority Scheduling:优先级调度

根据请求优先级决定执行顺序。

例如:

请求 优先级 调度倾向
A 高 优先处理
B 普通 正常处理
C 低 资源允许时处理

适合需要区分服务等级的场景,例如:

  • 企业付费用户。
  • 普通用户。
  • 后台批量任务。
  • 内部系统调用。

但如果高优先级请求长期大量到达,低优先级请求可能发生饥饿。

因此通常需要结合公平性和最大等待时间机制。

7.3 Token Budget:Token 预算调度

只限制请求数量是不够的。

推理引擎还可以限制当前迭代允许处理的 Token 总量。

例如:

max_num_batched_tokens = 4096

这意味着调度器需要在当前批次的 Token 预算范围内安排 Prefill 和 Decode 工作。

具体参数含义与实现方式依赖推理引擎和版本,不能简单理解为整个请求的最大 Token 数量。

Token Budget 可以避免某个长 Prompt 占用过多计算资源。

7.4 Chunked Prefill:分块预填充

对于超长 Prompt,可以拆分为多个 Chunk 逐步执行 Prefill。

例如:

原始 Prompt:8192 Token

Chunk 1:2048 Token
Chunk 2:2048 Token
Chunk 3:2048 Token
Chunk 4:2048 Token

分块后,调度器可以在不同 Prefill Chunk 之间安排 Decode 工作。

其目标是降低长 Prefill 对在线生成请求的干扰。

7.5 抢占与恢复

当 GPU 显存不足时,推理引擎可能需要暂时暂停部分请求。

常见处理方式:

  • Preemption:抢占请求。
  • Recompute:释放缓存,恢复时重新计算部分历史状态。
  • Swap:将部分缓存迁移到 CPU 内存或其他存储层。

抢占能够让系统在资源不足时继续接收和调度任务,但会带来额外开销。

例如,Recompute 会增加重复计算,Swap 会增加数据传输延迟。

因此,抢占通常需要结合请求优先级、缓存占用和服务目标进行决策。


八、Continuous Batching 的完整执行流程

一个在线推理服务的典型执行流程如下。

8.1 请求进入系统

客户端提交请求:

{
  "model": "example-model",
  "messages": [
    {
      "role": "user",
      "content": "什么是 Continuous Batching?"
    }
  ],
  "max_tokens": 512,
  "stream": true
}

API Server 接收请求后,执行:

  1. 参数校验。
  2. Tokenizer 编码。
  3. 请求 ID 分配。
  4. 生成参数初始化。
  5. 请求进入等待队列。

8.2 Scheduler 选择请求

Scheduler 检查:

  • 当前运行请求数量。
  • GPU 可用显存。
  • KV Cache 可用 Block。
  • 当前 Token 预算。
  • 请求优先级。
  • Prefill 和 Decode 的资源占用。

选择适合进入本轮执行的请求。

8.3 执行 Prefill

新请求进入 Prefill 阶段。

模型读取 Prompt Token,执行 Transformer 前向计算,建立初始 KV Cache。

如果 Prompt 较长,可以通过 Chunked Prefill 分块处理。

8.4 执行 Decode

请求进入 Decode 阶段。

每次迭代执行:

  1. 准备当前请求的输入 Token。
  2. 读取历史 KV Cache。
  3. 执行 Transformer。
  4. 计算 Logits。
  5. Sampling 选择下一个 Token。
  6. 更新请求状态和 KV Cache。

8.5 动态更新 Batch

每次迭代结束后:

  • 已完成请求退出。
  • 被取消请求释放资源。
  • 未完成请求继续保留。
  • 新请求根据预算和资源条件加入。
  • 被抢占请求等待恢复。

8.6 输出结果

生成的 Token 经过 Detokenizer 转换为文本。

对于流式请求,系统持续向客户端返回生成内容。

当请求结束时,释放相关 KV Cache 和调度资源。

flowchart TD
    A["客户端提交请求"] --> B["API Server 接收请求"]
    B --> C["Tokenize 与参数校验"]
    C --> D["进入 Waiting Queue"]
    D --> E["Scheduler 资源检查"]
    E --> F{"是否满足调度条件"}
    F -->|"否"| G["继续等待或调整调度"]
    G --> E
    F -->|"是"| H["分配 KV Cache Block"]
    H --> I["Prefill 处理 Prompt"]
    I --> J["进入 Decode"]
    J --> K["执行 Transformer 前向计算"]
    K --> L["Logits 与 Sampling"]
    L --> M["输出新 Token"]
    M --> N{"请求是否结束"}
    N -->|"否"| O["更新 KV Cache 与请求状态"]
    O --> P["重新组织 Batch"]
    P --> J
    N -->|"是"| Q["释放 KV Cache"]
    Q --> R["返回最终完成状态"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style M fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style N fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style O fill:#EAF3EC,stroke:#83A995,color:#315D49
    style P fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style Q fill:#EAF3EC,stroke:#83A995,color:#315D49
    style R fill:#DCEFE5,stroke:#4F8B70,color:#24563F

九、Continuous Batching 的异常处理机制

连续批处理需要处理的不只是正常生成,还包括请求取消、显存不足、执行失败和资源释放异常。

9.1 常见异常场景

异常 可能原因 处理方式
KV Cache 不足 长上下文或并发过高 限制新请求、抢占或回收
GPU OOM 权重、缓存或工作区超过容量 降低并发、限制长度、调整显存预算
请求取消 用户主动终止 标记请求并释放资源
模型执行失败 CUDA Kernel 或算子异常 终止请求、记录错误
Tokenizer 失败 输入格式或模型配置不匹配 返回请求错误
请求超时 排队过久或生成过慢 超时终止、释放资源
Worker 异常退出 GPU 故障或进程崩溃 Worker 恢复或服务重启

9.2 异常分支与资源回收

尤其需要注意:请求取消并不代表可以在任意时刻直接释放正在被 GPU Kernel 使用的显存。

实际实现需要协调执行状态、异步操作和缓存引用关系,确保资源不会被提前释放。

flowchart TD
    A["调度请求"] --> B["执行推理迭代"]
    B --> C{"是否发生异常"}
    C -->|"否"| D{"请求是否完成"}
    D -->|"否"| E["保留请求与 KV Cache"]
    E --> B
    D -->|"是"| F["等待相关执行完成"]
    C -->|"是"| G{"异常类型"}
    G -->|"KV Cache 不足"| H["检查缓存与并发预算"]
    G -->|"请求取消"| I["标记请求终止"]
    G -->|"模型执行失败"| J["终止当前请求并记录错误"]
    G -->|"超时"| K["执行超时清理"]
    H --> L{"是否可以恢复"}
    L -->|"是"| M["调整调度或执行抢占"]
    L -->|"否"| N["返回资源不足错误"]
    M --> B
    I --> F
    J --> F
    K --> F
    F --> O["确认不再使用相关缓存"]
    O --> P["释放 KV Cache 与请求资源"]
    P --> Q["更新调度状态"]
    N --> Q

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style J fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style K fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style L fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style M fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style N fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style O fill:#EAF3EC,stroke:#83A995,color:#315D49
    style P fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style Q fill:#E0F0FE,stroke:#93BCE8,color:#1E4976