想象你的衣橱：身体是基座大模型，它具备通用知识——会聊天、能翻译、懂常识，但面对法律合同、医疗报告这些专业场合，总差那么一点火候。LoRA 适配器就像衣橱里的一件件「场合外套」——写代码穿代码外套，答法律题穿法律外套。它极其轻薄，不改变身体本身，只在外侧叠加一层专业增量。可问题来了：外套多了，怎么收纳、怎么查找、怎么换装、哪些该永久缝进常服？这正是多 LoRA 管理的全部命题。这篇文章用「打理衣橱」的视角，带你走完 LoRA 从原理、训练、合并、收纳、动态切换到推理优化的完整链路。读完你会明白，管理几十个 LoRA 和管理十几件外套一样，靠的是清晰的结构与聪明的调度。

岗位关联

多 LoRA 管理是「参数高效微调」走向工程落地的最后一公里：掌握它，你就能用一份基座支撑几十个业务，让模型服务既省显存又快响应。这是大模型应用工程师与 MLOps 从业者的核心技能。

目录
  1. 可视化演示
  2. LoRA基础原理：那件「薄外套」
  3. 训练与导出：裁缝做新衣
  4. 适配器合并：把外套缝进常服
  5. 多任务管理：衣橱收纳系统
  6. 动态切换：出席场合换外套
  7. 推理优化：高效出门的艺术
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

展示LoRA适配器存储加载策略、权重叠加合并、动态切换机制及批量处理优化，交互切换深入理解多任务LoRA服务架构。

本节配有交互动效（进入视口后自动加载，约 3KB）。

存储加载：预加载与按需加载策略 预加载常用适配器到GPU显存实现即时切换，延迟最低 按需加载非常用适配器从磁盘到GPU，有少量延迟 显存 = Base(26GB) + N × LoRA(0.1GB) 池化管理平衡显存与延迟。

LoRA基础原理：那件「薄外套」

想象你是一个受过通识教育的人：能聊天、会写作、算得动数学，可一看到法律合同就犯难。这时有人递来一件「法律顾问外套」，穿上后你立刻懂了法务套路。这件外套的奇妙之处在于：它完全不改变你的身体，只是在外面加了一层薄薄的增量。这就是 LoRA 的第一直觉——基座模型是身体，LoRA 是外套。

LoRA（Low-Rank Adaptation，低秩适配）的具体做法是：把基座大模型的权重 W 完全冻结，只训练两个非常小的矩阵 A 和 B，用它们的乘积 BA 来近似「任务需要的权重增量 ΔW」。推理时，输入 x 同时经过基座与增量两条路径，结果叠加——就像身体照常走路，外套的风帽额外帮你挡风。因为 BA 的维度远小于 W，这件外套极其轻薄。

单层的前向公式如下，其中 r 是秩（rank），α 是缩放常数。r 决定增量表达能力的上限，实践常用 8~64；α 控制增量强度。两者组合起来就像是外套的「厚度旋钮」。

正是这种「只加薄薄一层」的设计，让衣橱能挂下几十件外套：每件都轻、薄、互不干扰。理解了这件「外套」怎么造出来，后面的管理问题就都有了对象。

h=Wx+αrBAxh = Wx + \frac{\alpha}{r}BAx
这个公式是说：最终输出 = 基座本能输出 + 一件按需缩放厚度的「低秩外套」输出。
  1. 基座前向x 是输入向量（比如一句话的语义表示），W 是基座被冻结的权重矩阵，这一项是原模型的本能输出。
    WxWx
  2. 低秩增量A 是 r×k 矩阵，B 是 d×r 矩阵，乘积 BA 的秩不超过 r，用极少的参数表达了任务专属的权重增量 ΔW。
    ΔW=BA\Delta W = BA
  3. 缩放系数α/r 是增量强度旋钮，防止增量过大破坏基座原有的通用能力。
    αr\frac{\alpha}{r}

训练与导出：裁缝做新衣

要给某类场合做一件新外套，裁缝得先量体——收集该任务的数据；再定版型——选好秩 r 与缩放 α；然后一针一线缝制——训练 A、B 两个小矩阵；最后挂进衣橱——导出为独立文件。这就是训练与导出一个 LoRA 的全过程。

训练 LoRA 时，基座 W 全程冻结、不产生梯度，只有 A、B 在更新。这意味着：一台普通 GPU 就能在一个 7B 基座上微调出任务版模型；训练产物不是「另一个 7B 大模型」，而是一个不到基座 1% 的小文件。以隐藏维度 4096、秩 16 为例，单层 LoRA 参数约 13 万，而该层全量参数超过 1600 万。

导出时，要把训练产物保存为「适配器文件」：记录 A、B 权重，附带元信息（基座版本、rank、α、任务名、训练日期）。每个任务一个独立文件，这就是衣橱里的一件外套。千万注意：不要直接覆盖基座权重，否则等于把外套改造成身体，从此失去即插即拔的灵活性。

裁缝把每件新外套标好尺码、面料和场合，挂进衣橱。训练与导出解决了「怎么造」，接下来要回答「哪些外套值得永久缝进常服」。

LoRA 参数量=r(din+dout),全量微调参数量=din×dout\text{LoRA 参数量} = r(d_{in}+d_{out}),\qquad \text{全量微调参数量} = d_{in}\times d_{out}
左边是两个小矩阵的参数总和，右边是完整权重矩阵的参数数量。秩 r 很小时，外套比身体轻几个数量级。
  1. 小矩阵尺寸A 有 r×d_in 个参数，B 有 d_out×r 个参数，两者相加就是 LoRA 需要训练和保存的全部参数。
    r×din+dout×rr \times d_{in} + d_{out} \times r
  2. 全量对比全量微调要更新整个 d_in×d_out 权重矩阵，当 r 远小于 d_in 和 d_out 时，LoRA 参数可小到几百分之一。
    din×doutd_{in} \times d_{out}

适配器合并：把外套缝进常服

某件外套你天天穿，干脆把它的版型永久叠进常服面料里——以后出门不用额外带外套。这就是 LoRA 合并：把增量矩阵直接写进基座权重，让「穿外套」变成「身体自带技能」。

合并的数学操作很朴素：取出 LoRA 的增量矩阵 ΔW，按缩放系数还原后，加到基座权重 W 上，得到新权重 W′。合并后，推理时不再需要加载适配器文件，省去额外的矩阵乘法与存储开销，部署体积也变小了。

但合并有个隐性代价：基座被「改造成新常服」后，其他 LoRA 若是在原基座上训练的，可能因为基座分布漂移而表现波动。因此工程实践要求：合并前保留原基座权重快照，合并后保留 LoRA 原始文件——就像裁缝先复印版型再缝制，随时可以回滚。

合并适合「长期稳定、不再频繁切换」的场景，比如部署瘦身；而「多任务常常要换」的场景，更适合保留独立外套。学会合并之后，衣橱里就有了两套状态：待穿的独立外套，和已缝进常服的能力。

W′=W+αrBAW' = W + \frac{\alpha}{r}BA
合并就是「把外套的版型复印到常服上」：基座权重 W 加上低秩增量 BA，得到一件新的常服 W′。
  1. 恢复增量从保存的 A、B 以及超参 α、r，还原出带缩放的增量矩阵 ΔW。
    ΔW=αrBA\Delta W = \frac{\alpha}{r}BA
  2. 叠加基座把增量逐元素加到基座权重上，形成合并后的新权重矩阵。
    W′=W+ΔWW' = W + \Delta W

多任务管理：衣橱收纳系统

外套超过十件，随手乱扔就会出门找不到。衣橱需要一套收纳系统，LoRA 也一样：任务映射、命名规范、版本管理、元信息注册，缺一不可。

工程上，一个多 LoRA 管理表（registry）通常包含四类信息：任务标识（法律、医疗、客服）、适配器标识与版本（lora-law-v1.2）、基座模型标识（它基于哪个基座训练），以及超参与评估指标（rank、α、验证集得分）。请求进来时，路由层查表定位对应适配器，像按标签取衣一样准确。

目录结构建议按「基座 / 任务 / 版本」三级组织，例如 base-7b-chat/law/lora-law-v1.2。元信息与权重一同存放，让任何同事拿到文件就知道这件外套怎么穿。多 LoRA 事故的根源，十有八九是命名混乱或映射表缺失。

收纳系统让「找衣服」从翻箱倒柜变成查表，零成本。有了它，动态切换才敢放心自动化——下一节就是真正的「出门换装」。

Stotal=∣Wbase∣+∑i=1N∣ΔWi∣S_{\text{total}} = |W_{\text{base}}| + \sum_{i=1}^{N}\left|\Delta W_i\right|
整个「衣橱」的体积 = 一份基座（共享的身体）+ N 件外套的增量之和。外套多但每件都薄，总空间增长很缓慢。
  1. 基座只存一份N 个任务共享同一个基座，基座权重在存储与显存中都只占一份。
    ∣Wbase∣|W_{\text{base}}|
  2. 增量线性累加每多一个任务，只多一份很小的适配器增量，总存储随 N 线性增长，但斜率极低。
    ∑i=1N∣ΔWi∣\sum_{i=1}^{N}|\Delta W_i|

动态切换：出席场合换外套

上午开庭穿西装，下午健身房换运动服，晚上聚会换休闲装。多 LoRA 服务也是这个节奏：同一个基座进程，不同请求来自不同领域，需要快速把对应适配器「穿上」。

动态切换有三个关键动作：按需加载、缓存、路由。请求进入后，路由层判断任务域（关键词规则或分类模型），去缓存中查找适配器；缓存未命中，就从磁盘把 LoRA 权重读入显存，替换当前激活的适配器。热适配器常驻缓存，冷的则回收让位。

路由准确率直接决定 p_hit：路由错了，不仅要多一次 miss，还会「穿错外套」答错题。所以生产环境常用双层策略——先按任务标识精确路由，兜底用通用适配器。切换开销必须纳入 SLO 监控，因为它是多 LoRA 服务最重要的延迟变量。

常穿的外套挂门口（缓存），不常穿的收进衣橱深处（磁盘）。换装的核心不是「快」，而是「在对的时间穿对的外套」。切换机制就绪后，最后一公里是让整个衣橱高效运转。

E[T]=phit⋅Tcache+(1−phit)⋅TloadE[T] = p_{\text{hit}}\cdot T_{\text{cache}} + (1-p_{\text{hit}})\cdot T_{\text{load}}
请求的平均等待时间 = 命中缓存的比例乘命中延迟，加上未命中比例乘加载延迟。命中率越高，换装越快。
  1. 命中路径适配器已在显存缓存中，直接进入推理，延迟约等于一次普通前向。
    phit⋅Tcachep_{\text{hit}}\cdot T_{\text{cache}}
  2. 未命中路径需要读取权重文件、写入显存、替换旧适配器，延迟显著更高。
    (1−phit)⋅Tload(1-p_{\text{hit}})\cdot T_{\text{load}}

推理优化：高效出门的艺术

一家人同时出门，不必每人重买一件同款风衣——共享同一件底衣，各自套自己的外套。多 LoRA 批量推理同理：一批请求混合了多个任务，先共享基座前向，再分组叠加各自的增量。

朴素做法是每个任务单独跑一遍完整模型，基座计算 WX 被重复 N 次。优化做法：把整批 X 一次性通过冻结基座算出 WX，再按路由把各任务子集 X⁽ⁱ⁾ 分别叠加 ΔWᵢX⁽ⁱ⁾。基座计算只花一份，增量计算又轻又快。

工程上还可配合合并做「瘦身」：长期沉淀的适配器合并进基座并做量化，减少运行时增量层数；显存管理上，闲置适配器优先卸载，为 batch 预留空间。最后用监控盯住各任务延迟分位数与缓存命中率，指导容量规划。

高效出门的秘诀不是变魔术，而是「共享能共享的、只计算必要的」。这整套衣橱管理法，让几十件 LoRA 在服务端井然有序——这就是多 LoRA 管理从理论到落地的完整闭环。

Y=WX+∑i=1kΔWiX(i)Y = WX + \sum_{i=1}^{k}\Delta W_i X^{(i)}
混合 batch 的输出 = 全体共享的一次基座前向 + 每个任务小组各自的低秩增量。共享能共享的，只算必要的。
  1. 共享基座前向混合 batch X 统一过一次冻结基座，得到所有行共用的基础输出。
    WXWX
  2. 分组增量叠加X 按任务路由拆成 k 组，每组只叠加自己的低秩增量，最后拼回完整输出。
    ∑i=1kΔWiX(i)\sum_{i=1}^{k}\Delta W_i X^{(i)}

AI 应用场景

企业多领域客服中台

阶段：推理部署与动态调度

解决的问题：传统做法为每个领域单独部署一个大模型，成本随领域数线性膨胀；改用单一通用模型则各领域效果都不理想。多 LoRA 方案让一份基座承载多个领域，每个领域只是一件薄外套。

具体案例：某企业客服系统基于一个 7B 对话基座，训练了「售前咨询」「售后维权」「产品故障排查」三个 LoRA。请求先经意图路由命中对应适配器，再动态加载推理。缓存命中率稳定在 90% 以上，单张 GPU 同时承载三个领域。

电商文案的版本上线与回滚

阶段：微调训练与模型发布

解决的问题：文案风格随营销活动频繁变化，全量重训周期长且影响线上稳定。LoRA 训练快、产物小，天然适合高频迭代。

具体案例：电商团队每周训练一批新的风格 LoRA，先离线评测再替换线上适配器文件；活动结束后秒级切回旧版，无需重启服务。基于多 LoRA 管理表的命名与版本规范，发布和回滚都像从衣橱里换一件外套那样轻。

私有化部署瘦身

阶段：模型部署优化

解决的问题：端侧或私有化设备显存有限，同时加载基座和多个 LoRA 增量层压力大。合并与动态切换的组合拳可以显著压缩部署体积。

具体案例：把频繁使用的 LoRA 精确合并进基座（W+ΔW）后再量化，设备只需存一份模型；新能力以独立 LoRA 形式下发并按需切换。部署体积从「1 基座 + N 适配器」降为「1 合并模型 + 少量热换 LoRA」。

Python 演示

python108 行
import numpy as np  class BaseModel:    """基座模型: 模拟大模型中的一个线性权重层"""     def __init__(self, d_in, d_out, seed=0):        rng = np.random.default_rng(seed)        self.W = rng.normal(0, 0.1, (d_out, d_in))     def forward(self, x):        return x @ self.W.T  class LoRAAdapter:    """单个 LoRA 适配器: 只持有低秩矩阵 A B"""     def __init__(self, d_in, d_out, rank=4, alpha=1.0, seed=1):        rng = np.random.default_rng(seed)        self.rank = rank        self.alpha = alpha        self.A = rng.normal(0, 0.02, (rank, d_in))        self.B = np.zeros((d_out, rank))     def delta_w(self):        """返回增量矩阵: (alpha / rank) * B @ A"""        return (self.alpha / self.rank) * (self.B @ self.A)     def infer(self, base, x):        """推理: h = Wx + (alpha/rank)BAx, 不修改基座"""        return base.forward(x) + x @ self.delta_w().T  def make_base(d_in, d_out, seed=0):    """构造低秩通用基座: 后续各任务只叠加小增量"""    rng = np.random.default_rng(seed)    theta = rng.normal(0, 1, (d_out, 4)) @ rng.normal(0, 1, (4, d_in))    W = theta + 0.1 * rng.normal(0, 0.2, (d_out, d_in))    base = BaseModel(d_in, d_out)    base.W = W    return base  def task_delta(d_out, d_in, scale, seed):    """生成低秩任务增量: 模拟领域专属知识差异"""    rng = np.random.default_rng(seed)    return scale * rng.normal(0, 1, (d_out, 2)) @ rng.normal(0, 1, (2, d_in))  def make_split(theta, n_tr, n_te, seed):    """按同一目标函数切分训练集与测试集"""    rng = np.random.default_rng(seed)    x_tr = rng.normal(0, 1, (n_tr, theta.shape[1]))    y_tr = x_tr @ theta.T    x_te = rng.normal(0, 1, (n_te, theta.shape[1]))    y_te = x_te @ theta.T    return (x_tr, y_tr), (x_te, y_te)  def train_adapter(base, x, y, rank=4, lr=0.2, epochs=500):    """梯度下降训练 LoRA: 只更新 A B, 基座冻结"""    d_in = base.W.shape[1]    d_out = base.W.shape[0]    adapter = LoRAAdapter(d_in, d_out, rank)    n = len(x)    for _ in range(epochs):        preds = base.forward(x) + x @ adapter.delta_w().T        grad = 2 * (preds - y).T @ x / n        scale = adapter.alpha / adapter.rank        dA = scale * (adapter.B.T @ grad)        dB = scale * (grad @ adapter.A.T)        adapter.A -= lr * dA        adapter.B -= lr * dB    return adapter  def run():    d_in, d_out, n_tr, n_te = 64, 32, 400, 100    base = make_base(d_in, d_out)    registry = {}    tasks = [("法律问答", 10), ("医疗问答", 20)]     for name, seed in tasks:        delta = task_delta(d_out, d_in, 0.6, seed)        theta = base.W + delta        (x_tr, y_tr), (x_te, y_te) = make_split(theta, n_tr, n_te, seed + 1)        adapter = train_adapter(base, x_tr, y_tr, rank=4)        registry[name] = adapter        err0 = np.mean((base.forward(x_te) - y_te) ** 2)        err1 = np.mean((adapter.infer(base, x_te) - y_te) ** 2)        print(name, "LoRA参数:", adapter.A.size + adapter.B.size,              "基座参数:", base.W.size, "MSE:", round(err0, 4), "->", round(err1, 4))     for name, seed in tasks:        delta = task_delta(d_out, d_in, 0.6, seed)        theta = base.W + delta        (x_tr, y_tr), (x_te, y_te) = make_split(theta, n_tr, n_te, seed + 2)        adapter = registry[name]        err = np.mean((adapter.infer(base, x_te) - y_te) ** 2)        print("路由->", name, "MSE:", round(err, 4))     base.W = base.W + registry["法律问答"].delta_w()    del registry["法律问答"]    print("合并完成, 剩余适配器:", list(registry.keys()))  if __name__ == "__main__":    run()
目的：用 numpy 从零模拟两个 LoRA 的训练、按任务动态切换、以及合并入基座的完整流程，直观演示多 LoRA 管理的三个核心操作。
  1. self.A = rng.normal(0, 0.02, (rank, d_in))A 随机初始化、B 置零，保证初始增量为零，训练从基座能力出发。
  2. return (self.alpha / self.rank) * (self.B @ self.A)把低秩乘积放大 α/r，得到真正要叠加的增量矩阵。
  3. return base.forward(x) + x @ self.delta_w().T推理时「基座 + 增量」两条路径相加，基座完全不被改动。
  4. grad = 2 * (preds - y).T @ x / n算出损失对增量矩阵的梯度，这是训练的唯一信号。
  5. adapter.A -= lr * dA只更新小矩阵 A，基座权重从头到尾没有出现。
  6. registry[name] = adapter训练完把适配器登记进「衣橱」，供后续路由取用。
  7. base.W = base.W + registry["法律问答"].delta_w()合并就是把增量写进基座，之后该任务不需要再穿外套。

常见误区

误区「我有 5 个 LoRA，不就是训练一个覆盖一个？最后留下的那个生效呗。」很多初学者把 LoRA 当成对基座的一次性修改，以为多个 LoRA 无法共存。

正解每个 LoRA 都是独立的小文件，包含各自的 A、B 矩阵，互不覆盖。它们像衣橱里每件独立的外套，基座这个「身体」始终不变。推理时按任务选择穿哪一件，而不是让新外套「毁掉」旧外套。

为何常见：全量微调的习惯是「改权重、覆盖模型」，这种单模型思维容易让人误解 LoRA 的即插即拔特性。

误区「合并就是把 LoRA 烧进基座，文件没了，再也回不去了。」有人不敢做合并，怕一次操作损失一个模型资产。

正解合并的计算是 W + ΔW，发生在加载到内存的权重副本上，磁盘里的 LoRA 文件原封不动。合并不等于删除，更像把外套的版型复印到常服上，原版型图纸还好好收在抽屉里，随时能回滚。

为何常见：把「合并」误解为「覆盖写入」，忽视了合并只是一次可逆的数学加法。

误区「秩越大，LoRA 容量越大，效果肯定越好，那就设 256！」不少人在调参时盲目加大 rank。

正解rank 决定增量表达能力的上限，但过大的 rank 会带来三笔账：存储变大、显存加载变慢、更容易在少样本任务上过拟合。实践中 rank 8~64 通常够用，追求更大容量不如先优化数据质量。

为何常见：把「模型越大越强」的直觉迁移到低秩适配上，忽略了 LoRA 本来就是「小即美」的设计哲学。

误区「动态切换要加载卸载太慢，我把所有 LoRA 全部常驻显存，切换时直接指过去不就行了？」

正解显存是有限资源，把所有适配器常驻会挤压 batch 空间、降低吞吐，甚至 OOM。更稳妥的做法是热适配器缓存 + 冷适配器按需加载，并用命中率指标指导缓存容量。衣橱再大也不能把全部衣服穿在身上。

为何常见：只看到「省去加载时间」的一面，忽略了显存占用与吞吐下降的隐性代价。

误区「把两个 LoRA 的增量直接加起来 W+ΔW₁+ΔW₂，不就得到一个又能写代码又能答法律题的二合一模型？」

正解简单叠加在数学上可行，但任务之间常常互相干扰——A 任务和 B 任务对同一层权重的需求可能方向相反，直接相加可能导致两边都掉点。可靠做法是加权插值、SLERP 或基于示例的融合方法，属于进阶话题。把雨衣和羽绒服缝在一起，并不等于一件防水又保暖的完美外套。

为何常见：线性思维忽略了不同任务增量之间的冲突，把「相加」等同于「融合」。

面试题

Q1. LoRA 的核心设计思想是什么？

单选题 · easy

  • A.训练全量模型权重
  • B.冻结基座学低秩增量← 正确答案
  • C.复制基座单独训练
  • D.蒸馏得到轻量模型

答案：B。LoRA 的关键是冻结基座权重 W，只训练低秩矩阵 A、B 来近似增量 ΔW=BA，相当于给身体加一件薄外套而非重造身体。A 是全量微调，C 是副本训练，D 是蒸馏，都不是 LoRA 的核心。

Q2. LoRA 中 B 矩阵通常被初始化为？

单选题 · easy

  • A.全零矩阵← 正确答案
  • B.随机高斯矩阵
  • C.单位对角矩阵
  • D.基座权重副本

答案：A。B 初始化为零、A 随机初始化，这样训练开始时 BA=0，增量不会破坏基座能力。若 B 随机初始化，模型一开始就带着「乱穿的外套」输出，训练更容易不稳定。

Q3. LoRA 合并进基座的正确公式是？

单选题 · mid

  • A.W' = W + (α/r)BA← 正确答案
  • B.W' = W − (α/r)BA
  • C.W' = W × (α/r)BA
  • D.W' = W + (r/α)AB

答案：A。合并就是把带缩放的增量叠加到基座权重上。α 是缩放常数、r 是秩，系数是 α/r；B 在前、A 在后，维度才能对齐。符号、方向和矩阵顺序错一个都不对。

Q4. 多 LoRA 动态切换主要为了优化哪类成本？

单选题 · mid

  • A.显存占用与切换延迟← 正确答案
  • B.训练数据标注量
  • C.基座模型参数量
  • D.网络带宽占用

答案：A。动态切换的意义在于：同一基座服务多个任务时，按需加载适配器，用缓存降低切换延迟、用卸载控制显存峰值。它不改变训练数据量、基座参数或网络带宽。

Q5. 增大 LoRA 的 rank 最直接的影响是？

单选题 · mid

  • A.增量能力变强但存储变大← 正确答案
  • B.基座模型权重自动缩小
  • C.训练数据需要量必然变少
  • D.推理速度一定会直线加快

答案：A。rank 越大，低秩增量能表达的信息越丰富，但 r(d_in+d_out) 的存储也越大，加载切换更慢，还容易过拟合。它不会缩小基座、不会减少数据需求，更不会加速推理。

Q6. 关于两个 LoRA 的权重直接叠加融合，下列说法正确的是？

单选题 · hard

  • A.直接相加通常效果最优
  • B.任务冲突时要借助插值融合← 正确答案
  • C.融合后一定性能下降
  • D.融合只会影响推理速度

答案：B。不同任务的增量方向可能互相干扰，直接相加常常两败俱伤，需要加权插值或 SLERP 等方法调衡；但简单相加也不是「一定掉点」——同源相似任务可能不降。选项 B 更准确。

Q7. 混合多任务的批量推理优化核心做法是？

单选题 · hard

  • A.每个请求单独算一次基座前向
  • B.共享 WX 再分组叠加增量← 正确答案
  • C.让所有请求强行使用同一适配器
  • D.把基座权重复制多份并行计算

答案：B。优化关键是一次 WX 算出共享基底，再按任务分组各自叠加 ΔWᵢX⁽ⁱ⁾。逐请求算基座是浪费，强行统一适配器会答错题，复制基座权重则显存爆炸。

Q8. 将 LoRA 合并进量化后的低比特基座时需要注意？

单选题 · extreme

  • A.合并后再量化通常有精度损失← 正确答案
  • B.量化过程完全不会损失精度
  • C.合并时不需要考虑缩放系数
  • D.合并只影响训练不影响推理

答案：A。在低比特基座上合并 LoRA，通常需要反量化→精确叠加→再量化的流程，每一步都可能引入舍入误差；直接量化更会损失增量精度。因此常采用 BF16 高精度合并后再量化，而不是在量化权重上硬加。

Q9. 多 LoRA 管理通常包含哪些环节？

多选题 · easy

  • A.适配器独立文件存储← 正确答案
  • B.任务到适配器映射表← 正确答案
  • C.重新训练整个基座
  • D.推理时按路由动态加载← 正确答案

答案：ABD。多 LoRA 管理 = 存储规范 + 映射表 + 动态加载切换。C 是重训基座，与「参数高效微调、共享一份基座」的管理思路背道而驰。

Q10. 以下哪些属于 LoRA 相对全量微调的优势？

多选题 · mid

  • A.训练参数少显存占用小← 正确答案
  • B.多任务共享同一基座← 正确答案
  • C.不需要训练即可生效
  • D.切换成本低便于热更新← 正确答案

答案：ABD。LoRA 只训练小矩阵，显存友好；基座冻结，多个任务可共存共享；适配器文件小，切换快、适合热更新。但 LoRA 仍然需要训练才能生效，C 错误。