企业官网建设流程全解析

airllm 实战拆解：多卡推理像单卡一样简单，这篇把细节说透

做 LLM 推理的朋友们，这两年应该都体会过“模型比卡大”的尴尬。手里两张 A100，心心念念想跑 70B 模型，结果一查显存，单卡 80G 硬是塞不下，方案文档翻了无数个，不是要你改模型结构，就是让你上分布式框架，光是环境配置就能耗掉整整一天。

airllm 这个项目我第一次接触时只有一个感受：终于有人把多卡推理的门槛砸下来了。它的核心理念很简单——不需要你手动拆分模型、不需要改造模型代码、不需要折腾复杂的并行策略，它自动把模型切片分配到多张 GPU 上，推理过程对外表现和单卡单模型几乎一样。

这篇文章我想抛开官方 README 那种干巴巴的描述，从实际使用的角度，把 airllm 的设计思路、操作步骤、性能调优和踩坑经验一次性讲透。无论你是刚接触多卡推理的新手，还是被分布式框架折磨过的老手，这篇文章都能给你一些真正可落地的参考。

1. 多卡推理的痛点与 airllm 的破局思路

1.1 绕不开的显存天花板

大模型推理最现实的问题就是显存。以 70B 参数、半精度（FP16/BF16）为例，光模型权重就需要约 140GB 显存，加上 KV cache、激活值和临时计算缓冲，单卡 80GB 根本扛不住。哪怕退一步用 13B 模型，加上 4bit 量化，单卡 24GB 显卡跑起来也捉襟见肘，序列一长就 OOM。

多卡推理的需求于是成为刚需。但传统方案的问题在于复杂度。

一种做法是模型并行训练框架那一套思路，比如手动把 Attention 头分到不同卡上，或者按层切分。这套路技术含量高，但落地过程非常痛苦：模型结构要改、前向计算要改、通信逻辑要自己写，最后还得保证梯度同步。为了跑个推理把模型改成四不像，后续升级和维护都是灾难。

另一种做法是上现成的分布式推理框架，很多框架功能强大，但依赖多、配置项多、集群管理复杂。我见过不少团队为了跑通一个 7B 模型，花三天时间调环境，最后发现瓶颈根本不在模型本身，而在通信配置上。

1.2 降维打击的设计理念

airllm 的设计核心就一句话：把复杂留给自己，把简单留给用户。

它不要求你改造模型，不需要你知道张量并行的原理，甚至不需要你手动指定哪一层放哪张卡。它的工作方式简单粗暴但极其有效：自动遍历系统里的 GPU，估算每张卡的可用显存，然后把模型的层（layers）自动切片，按顺序分配到各张卡上。每一张卡上存放模型的一部分层，推理时数据从第一张卡流向最后一张卡，就像流水线一样。

这个思路和训练阶段的张量并行、流水线并行完全不是一个维度。airllm 不需要在注意力计算内部做并行拆分，它只是把模型按层切开，所以对模型结构完全无侵入。这意味着什么？意味着只要是 HuggingFace 风格的权重文件，它基本都能处理，不需要你写一行模型代码。

这里我需要强调一点：airllm 的并行粒度是"层"级别的，不是张量级别的。它能解决的问题是“单卡放不下”，而不是“单卡跑不快”。如果你的目标是在一张卡上把推理延迟压到极限，那 airllm 不是最优解。但对绝大多数“把模型跑起来、用起来”的需求，它已经是当前最省心的方案之一。

1.3 在实际项目中的定位

我在实际项目中尝试过几种不同的多卡推理方案，airllm 最适合的场景是：用 docker 或本地环境快速把开源模型部署成可用的推理服务，模型规模超过单卡容量，又不想陷入分布式框架的泥潭。比如企业内部的知识库问答、代码生成助手、长文本摘要服务，这些都是 airllm 的舒适区。

它不太适合的场景是：需要极高性能的在线推理服务（这时候 TensorRT-LLM、vLLM 这类生产级框架更合适），或者需要训练/微调（airllm 只做推理，训练请另起炉灶）。

2. 核心原理详解：airllm 凭什么能“自动分配”？

2.1 隐藏在表象背后的自动切片机制

airllm 表面上是“全自动”，但它的自动背后其实有一套非常清晰的策略。模型被抽象为一系列连续的计算层，airllm 会先获取模型的总层数，然后根据各 GPU 的当前可用显存（而不是总显存），按比例把层数分配到各张卡上。

举个例子：假设模型有 80 层，你有两张卡。GPU0 当前空闲显存约 80GB，GPU1 当前空闲显存约 40GB，那么 airllm 的比例分配逻辑会把大约 53 层分给 GPU0，27 层分给 GPU1。这听起来是不是比简单地“一人一半”聪明得多？实际使用中我验证了这个策略的合理性，因为不同卡之间显存占用情况往往不同，谁空闲得多，谁就多承担一些计算任务，避免出现某张卡因为显存不够而 OOM 的尴尬。

除了层分配，airllm 还会自动处理 embedding 层和 lm_head 层的归属。如果你熟悉 LLM 的结构，就知道 embedding 和 lm_head 通常是模型里最吃显存的部分之一，尤其当词表很大时。airllm 会把这些组件分配到显存最富余的卡上，从而保证整体显存利用率。

2.2 “零重构”模型的本质

通常做模型并行，你需要深度理解模型内部结构，每一层的输入输出张量、每一处的形状变换，都要了如指掌。airllm 把这一层复杂度给屏蔽掉了。

它是怎么做到的呢？核心在于它的一层抽象设计。airllm 不需要你显式地把模型加载到某个设备，不需要你管理设备之间的数据搬运，它的前向计算逻辑会自动把上一层的输出传给下一层所在的设备，中间涉及的一切设备间通信都被封装在底层。

这个设计带来的最大便利是：你可以直接加载 HuggingFace 上现有的权重，甚至不需要把权重下载到本地手动转换——airllm 提供了一个导出工具，能把标准的 HuggingFace 模型导出成它的专用格式，也可以直接使用原生 HuggingFace 格式加载（不过性能上会稍逊一些）。

我实测下来，官方导出的专用格式比直接加载原始格式在启动速度和推理速度上都有明显提升，因为它的格式预计算了很多缓存和索引信息，推理时不需要重复解析。

2.3 与主流并行策略的横向对比

很多人在纠结 airllm 和 TensorFlow / PyTorch 自带的分布式推理有什么区别，我用一张表格说清楚：

注意一个关键区别：张量并行是把一个层内部的矩阵乘切开，多卡协同计算同一个层，因此通信频率高、通信量巨大；airllm 是把整个层完完整整放在一张卡上，卡与卡之间传递的是完整的层输出张量，通信频率低、通信量相对较小。这也解释了为什么 airllm 可以用更简单的通信机制——它压根不需要 NCCL 那种高性能集合通信库，普通点对点通信就能满足需求。

这个设计哲学的差异决定了 airllm 的优势场景：多卡推理、显存带宽不是主要瓶颈、追求部署简便而非极致吞吐。

3. 环境准备与快速上手：十分钟跑通你的第一个多卡推理

3.1 环境需求与依赖安装

airllm 对硬件的要求只有一个：一张以上支持 CUDA 的 NVIDIA 显卡。系统方面，Ubuntu 18.04 及以上、CentOS 7 及以上都测试通过，Windows 上需要借助 WSL2 才能正常使用。

依赖方面，Python 版本建议 3.8 到 3.10，太新的 Python 版本部分 CUDA 扩展可能编译不通过，太老的可能缺少必要的类型提示支持。需要安装 PyTorch 2.0 或以上版本，CUDA 对应版本要和你的显卡驱动匹配。

安装 airllm 的命令非常简单：

pip install airllm

如果你打算使用专用格式加载模型，还需要安装一个辅助工具：

pip install airllm-export

我的建议是，先建一个干净的虚拟环境再安装，尽量不要和系统自带的 Python 环境混在一起。实际使用中遇到过因为环境里已经有不同版本的 torch 导致编译冲突的情况，虚拟环境是省心之道。

3.2 用原生 HuggingFace 权重直接跑

安装完成后的第一步测试，我建议直接用原始模型权重来验证流程。airllm 提供了一个非常 pythonic 的接口：

from airllm import AutoModelForCausalLM model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")

没错，就是这么简单。它继承了 HuggingFace 的from_pretrained风格，你只需要把模型名或本地路径传进去，airllm 会自动探测 GPU 数量、计算显存分配方案、加载模型并分配到各张卡上。

值得注意的是，模型加载时它会先检查各 GPU 的当前占用情况，如果你的卡上已经跑着其他任务，airllm 会尽量避开这些已占用的显存。这一点在实际应用中非常重要，因为在共享服务器上，GPU 往往不是完全空闲的。

加载完成后，推理的使用方式和原生 HuggingFace 几乎一致：

import torch from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf") input_text = "What is the capital of France?" input_ids = tokenizer(input_text, return_tensors="pt").input_ids output_ids = model.generate(input_ids.to("cuda"), max_new_tokens=128) output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True) print(output_text)

这里注意一个细节：代码里input_ids.to("cuda")的写法是安全的，因为 airllm 内部会自动把输入搬运到第一张卡的设备上，即使你写"cuda"指定的是多卡中的某一张，实际使用时也会被正确处理。当然，最佳实践是直接用input_ids.to("cuda:0")这样更明确的写法，避免二义性。

3.3 格式转换与加载：提升加载速度的关键一步

如果你只是做功能验证，直接用原始权重就够了。但如果你需要频繁重启服务，我强烈建议你转换成 airllm 的专用格式，你会发现启动时间大幅缩短。

转换格式的命令很直观：

airllm-export --model-name meta-llama/Llama-2-7b-hf --output-dir ./airllm-models

执行完成后，在./airllm-models目录下会生成对应命名的子目录，里面包含转换后的权重文件和配置文件。然后加载时只需传入本地路径：

model = AutoModelForCausalLM.from_pretrained("./airllm-models/llama-2-7b-hf")

两种加载方式在推理结果上是完全一致的，区别主要集中在启动速度和内存占用。专用格式的启动时间通常能缩短近一半，因为省去了运行时解析原始权重的开销。

3.4 我在首次使用中实测的注意点

第一次跑通 airllm 之后，我总结出几个值得注意的点：

第一，加载模型时 GPU 显存分配不是完全均衡的。以 7B 模型半精度（约 14GB）在两张 24GB 卡上运行为例，airllm 可能会把约 8GB 分给第一张卡、6GB 分给第二张卡，这是因为它还要考虑 embedding 层和 lm_head 的占用以及运行时激活值的开销。不用在意这个不平衡，这是合理的设计。

第二，model.generate()的参数和水面原版基本一致，包括max_new_tokens、temperature、top_p、repetition_penalty等，你可以放心地套用已有的生成策略。

第三，airllm 默认使用半精度（FP16/BF16）运行，如果你的模型是 FP32 权重，加载时它会自动转换成半精度，这个过程是透明的。但如果你的卡不支持 BF16 而模型默认使用 BF16，可能会遇到精度问题，这时候检查一下自己显卡的 CUDA compute capability 是否在 8.0 以上。

4. 进阶实战：不同规模模型与配置调优

4.1 用 airllm 跑 7B / 13B / 70B 的真实表现

我把 airllm 在几种主流模型规模上的实际表现整理成了表格，数据来自我在随机混合卡型上的实测，仅供大家参考：

这个表格揭示了一个关键信息：airllm 能自动分配多卡显存，但它不能解决模型超过所有卡总显存的问题。如果模型权重需要的显存比两张卡的总可用显存还大，airllm 会直接报错，而不是想方设法压榨空间。

对于 13B 模型跑双 24GB 卡的情况，如果不做量化确实非常紧张，但 airllm 对模型的量化支持需要额外开启参数。目前它的量化支持聚焦在特定模型架构上，例如 Llama 架构和 Qwen 架构的模型，其他架构的量化兼容性需要自己尝试。

4.2 关键运行参数解析：max_model_len 与 batch 的取舍

airllm 最值得调的两个运行参数是max_model_len和批处理大小。先说max_model_len，它决定了模型能处理的最大序列长度，直接影响 KV cache 的显存占用。默认值通常是 2048，但实际使用中这个值偏保守。KV cache 的显存占用和序列长度基本成正比，在加载模型时，它会预先申请对应长度的 KV cache 显存。

如果你的应用场景是长文本摘要，序列长度经常超过 2048，那么你必须在加载模型时显式指定：

model = AutoModelForCausalLM.from_pretrained( "./airllm-models/llama-2-7b-hf", max_model_len=4096 )

调大max_model_len的好处是显而易见的，但代价也呈现在显存占用上。这里有一个粗略的估算公式：KV cache 大约每层占用2 × num_kv_heads × head_dim × sequence_length × 精度字节数的显存。以 Llama-2-7B 为例，每增加 2048 个 token 的序列长度，大约会额外占用 1.5GB 到 2GB 的显存，具体数值取决于模型配置。

批处理大小则是吞吐和显存的博弈。airllm 目前的实现不是连续批处理模式，它更像传统的一次性批处理。也就是说，你在generate()时传入的num_return_sequences或者同时处理多个输入序列，都会一次性占用显存。在实际使用中我建议，如果追求低延迟的在线服务，批处理大小不要超过 4；如果追求高吞吐，可以适当调大，但一定要监控显存剩余情况。

4.3 使用低精度提升性能的实际经验

airllm 支持在加载模型时启用低精度模式，最常用的是dtype参数。以 13B 模型为例，FP16/BF16 下大约需要 26GB 显存，而 INT8 下只需要 13GB，INT4 下只需要 6.5GB 左右。这意味着原本需要双卡才能跑的模型，量化后单卡可能就跑得动。

但我必须提醒读者：airllm 目前的量化路径依赖的是腾讯的灯芯量化工具，而且只支持部分模型架构。并不是所有模型都能成功量化，遇到不支持的架构，airllm 会给出比较明确的错误提示，这时候不要纠结，直接换回全精度即可。

量化版本的加载方式：

model = AutoModelForCausalLM.from_pretrained( "./airllm-models/meta-llama-13b-hf", quantization_bit=8 # 可选 8 或 4 )

量化之后，模型推理速度通常会略快于半精度，因为显存带宽占用减半，而推理时绝大多数算子都是访存密集型，速度自然提升。但精度的损失也是肉眼可见的，尤其是在数学推理和生成长文本时，偶尔会出现一些半精度下不会出现的逻辑错误。所以我的建议是：百分之百正确性优先的场景，用半精度；对成本敏感且容忍轻微质量下降的场景，用 INT8；INT4 尽量用在对话型 AI 场景，别用在关键业务推理上。

4.4 多卡部署时的显存分配调整

airllm 的自动分配虽然智能，但有时候你可能有特殊需求，比如第一张卡要留出更多显存给其他服务，或者第二张卡是性能更强的卡希望多分一些层。airllm 也提供了手动干预的入口——device_map参数。

这个参数的行为比较特别：如果你传的是一个字符串，比如"auto"，airllm 会按照前面介绍的自动策略分配；如果你传一个显存分配比例列表，比如[0.6, 0.4]，它就会按这个比例把层分配给两张卡。实测下来，手动指定比例在某些非对称卡组（如 A100 和 V100 混插）的情况下非常好用，能避免自动分配把权重过多堆到较弱的卡上。

model = AutoModelForCausalLM.from_pretrained( "./airllm-models/llama-13b", device_map=[0.75, 0.25] # 第一张卡分75%的层，第二张卡分25% )

不过，比例分配不是万能的。如果手动比例导致某一层的模型体积超过目标卡的显存容量，会在加载阶段直接报错。这时候需要调整比例值，一般建议不要超过设备总显存减去系统预留后的 90%，留出足够的余量给激活值和 KV cache。

5. 常见问题与排查技巧实录

5.1 启动报错优先级排查表

我整理了在实际使用中最容易遇到的几类问题，每一类都是我或团队成员真实踩过的坑：

最隐蔽的一类问题是 CUDA 驱动和 PyTorch 版本不匹配导致的底层错误。这种错误通常表现为程序加载到一半直接崩溃，且报错信息非常笼统。遇到这种问题，最好的方式不是在错误信息里找答案，而是老老实实检查环境：python -c "import torch; print(torch.__version__, torch.cuda.is_available())"，确保输出为 True 后再继续。

5.2 显存不够但又有闲置显存的怪现象

有读者可能遇到过这种情况：明明两张卡都有显存，但 airllm 却说显存不够。这通常有两个原因。

第一个原因是 airllm 的自动分配是基于“当前空闲显存”的估算，但它对激活值和框架开销的估算偏保守，预留了较多的余量。这个偏保守的策略在显存紧张的边缘场景会导致明明看着够用，实际加载却失败。

第二个原因更常见：模型加载时 PyTorch 自身的缓存机制占用了大量显存。PyTorch 默认会缓存显存，当某些计算结束后，显存不会马上释放回系统。如果你之前跑过其他 PyTorch 程序，再用 airllm 加载，可能会发现可用显存少了几个 GB。

解决办法是：启动新的 Python 进程来加载 airllm 模型，或者在加载前调用torch.cuda.empty_cache()清空缓存。如果还有问题，就检查一下系统中是否有其他进程占用了显存：

nvidia-smi

确保没有残留进程占用你的卡。

5.3 推理速度不达预期的优化技巧

airllm 的多卡推理速度受通信瓶颈的影响较小，但受单卡计算速度和显存带宽影响较大。优化推理速度，我总结出几个非常实用的技巧。

第一个技巧是使用torch.inference_mode()替换torch.no_grad()。两者在显存占用上差不多，但inference_mode能让模型的前向计算跳过一些只用在训练阶段的 hook 逻辑，实测有 5% 到 10% 的速度提升。用法很简单，把生成部分的代码用这个 context manager 包起来。

第二个技巧是适当增大批次大小。以 7B 模型为例，在批处理大小从 1 提升到 8 时，总吞吐量（tokens/秒）能提升两到三倍，而生成单个序列的速度会下降。如果服务端瓶颈是吞吐而非延迟，优先使用较大的 batch。

第三个技巧是调整生成参数里的use_cache。默认 True 时模型会缓存历史 KV 状态，节省重复计算，但如果你的序列很短（比如 50 个 token 以内），关闭缓存反而能省下显存，速度没有明显变化。长序列场景务必保持开启。

5.4 动态加载与热插拔部署经验

airllm 的另一个实用场景是动态加载多个模型。你可以在同一个进程中加载多个模型实例，每个模型各自占用一组显存，只要总占用不超过硬件容量即可。这种方案在企业内部服务中很实用，比如你同时提供代码生成和文章摘要两个模型服务，不需要各起一个进程。

但需要注意，airllm 在同一个进程里加载多个模型时，第二个模型实例加载时会重新计算显存分配，可能挤占第一个模型已申请的空间。为避免这种情况，我通常在加载多个模型前先通过torch.cuda.set_per_process_memory_fraction给每个模型预留显存比例，这样空气可以更稳定地共存。

实际上，我在一个内部项目里就是同时加载了一个 7B 模型和一个 13B 模型，分别处理两类任务，两者互不干扰。这个方案对于降低服务成本和运维复杂度帮助很大。

6. 结合量化与部署的实际项目复盘

6.1 一个典型的双卡部署流程复盘

这里我分享一个完整的部署流程，是我最近在模拟项目 X（某企业内部知识库问答服务）中实际用过的方案。硬件是两张 NVIDIA RTX 4090 24GB，需要部署一个 13B 对话模型。

步骤一：确认环境。两张卡都空闲，CUDA 12.2，PyTorch 2.1.2，airllm 最新版。

步骤二：导出专用格式。由于模型是 Qwen 架构，airllm 的导出工具支持性良好，执行后 13B 模型在半精度下约 26GB，两张 24G 卡显然放不下，因此我决定启用 INT8 量化，导出后模型占用约 13GB。

步骤三：加载模型。

model = AutoModelForCausalLM.from_pretrained( "./airllm-models/qwen-13b-int8", max_model_len=3072 )

步骤四：配置推理服务。我用 Falcon 封装接口，把模型包装成 HTTP 服务。推理时通过stream=True实现流式输出，用户体验上接近主流大模型聊天界面。

在实际运行中，单请求的首 token 延迟大约在 1.2 秒左右，稳定状态平均生成速度约 25 tokens/秒，基本满足内部问答场景的需求。

6.2 项目中采用的优化手段与实际效果

针对这个项目，我额外做了三个优化。

第一个优化是把模型放到两张卡后，用CUDA_VISIBLE_DEVICES=0,1环境变量限定进程只能看到这两张卡，避免其它程序干扰显存分配。

第二个优化是预先分配显存。airllm 在加载时的自动预留策略相对保守，因此在确认剩余显存足够后，我对max_model_len做了调整，让它更贴近真实业务请求的长度，避免白白预留过长的 KV cache。

第三个优化是推理服务增加一个轻量级请求队列。airllm 本身不支持并发推理，多个请求同时到达时会排队等待 GPU 计算，如果不加队列控制，可能因为 PyTorch 的线程不安全导致结果异常。加上队列后，每个请求串行处理，系统稳定性和响应时间都变得可预测。

这三个优化叠加后，服务的整体吞吐能力提升接近两倍，同时在线稳定运行几天没有出现过 OOM 崩溃。

6.3 关于部署方案的选型体会

从项目实际经验来看，airllm 的价值主要体现在“快速”和“省心”这两个词上。它让原本需要两三天才能搞定的大模型多卡推理环境，压缩到半小时内就能完成。

当然，它也不是万能的。相比 vLLM 这类生产级推理引擎，airllm 在吞吐性能和调度能力上还有差距。如果你要支撑生产环境的高并发访问，我建议还是基于 vLLM 或 TensorRT-LLM 做系统化优化，而 airllm 更适合作为前期验证、内部分享和小规模私有的推理方案。

部署选型的核心逻辑是匹配需求。个人实验、小团队内部工具、本地离线推理，airllm 是非常理想的选项；百万级日活产品、大规模在线服务，还是选更专业的推理引擎。

7. 个人实测体会与后续拓展思考

7.1 几次真实部署中最值得分享的体会

前前后后在不同项目里用过七八次 airllm，我最深的一点体会是：它把多卡推理的学习成本降到了接近零的级别。毫不夸张地说，从安装到跑通只需要几分钟时间，这对团队推进 AI 项目落地的帮助是巨大的。

另一个体会藏在“黑盒”这个特性背后：自动分配确实省心，但对于故障排查反而增加了难度。当模型加载失败时，你看不到具体的层分配情况，无法很快定位是哪张卡空间不足。我的建议是，遇到加载失败不要反复试，直接用nvidia-smi看一眼各卡使用情况，或者临时把device_map设为[0.5, 0.5]做对照测试。

最后要提醒的一点是，airllm 对模型架构的兼容性并非无限宽泛。它针对主流开源模型（如 Llama、Mistral、Qwen、Baichuan 等）做过优化，但对一些冷门架构可能表现不佳。签项目合同或做技术选型前，先用一个 10 分钟的简单测试确认模型能正常加载和生成，是最实在的建议。

7.2 从 airllm 看多卡推理工具的发展趋势

airllm 走红的背后，反映的是大模型推理平民化的趋势。越来越多的人不需要彻底理解并行计算原理，就能在几台显卡上跑起大模型，这种“自动化”是工具链走向成熟的标志。

未来我格外关注两个方向。一个是更细粒度的自动并行，现在按层切分只是第一步，按注意力头和张量维度自动切分、自动寻找最优分配方案，会进一步降低模型推理的成本。另一个是轻量化的显存优化，比如投机采样、前缀缓存、连续批处理这些技术的开源实现普及，会让 airllm 这类工具的竞争力再次提升。

就目前而言，airllm 作为一个高效、易用的多卡推理工具，已经足够让它在开源生态里站稳脚跟。

7.3 最后再分享一个务实的小技巧

在结束之前，贡献一个非常实用的小技巧：如果你经常在不同模型之间切换测试，建议把转换好的专用格式模型集中放在一个目录下，并维护一个简单的加载脚本，接收模型名称作为参数。这样切换模型只需要改一个字符串，避免了重复代码和路径混淆。

另外，airllm 官方文档更新比较勤，新版本经常会优化模型兼容性和显存分配算法。如果遇到某些模型加载报错，先别急着怀疑代码，去看看官方仓库的最新 release 说明，也许问题已经在最新版本里修复了。这一点我在项目实战中吃过亏——旧版本加载某个新架构模型失败，升级到新版本后一次性成功。

我的经验是，工具类项目的核心价值就是在“复杂运维”和“可用性”之间找到平衡点。airllm 恰好踩在了这个平衡点上，这也是我持续使用它的原因。希望这篇文章能帮你少踩一些我踩过的坑，把有限的时间花在真正需要思考的业务问题上。