一、什么是 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 完成。
这会带来两个问题:
- 已完成请求占据批次位置,不能及时释放执行资源。
- 新到达的请求必须等待当前批次结束,无法及时利用 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 生成速度。
因此,推理引擎需要在两种工作负载之间进行平衡。
典型方法包括:
- 限制单轮 Prefill 的 Token 数量。
- 将长 Prompt 拆分为多个 Chunk。
- 控制 Decode 请求的调度优先级。
- 根据剩余 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 大小可以近似表示为:
其中:
- 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 接收请求后,执行:
- 参数校验。
- Tokenizer 编码。
- 请求 ID 分配。
- 生成参数初始化。
- 请求进入等待队列。
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 阶段。
每次迭代执行:
- 准备当前请求的输入 Token。
- 读取历史 KV Cache。
- 执行 Transformer。
- 计算 Logits。
- Sampling 选择下一个 Token。
- 更新请求状态和 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