LoRA / QLoRA · học một cặp ma trận nhỏ thay vì sửa toàn bộ trọng số

1Định nghĩa

LoRA (Low-Rank Adaptation, thích nghi hạng thấp) là kỹ thuật tinh chỉnh tiết kiệm tham số (Parameter-Efficient Fine-Tuning, viết tắt PEFT): thay vì sửa mọi trọng số trong fine-tuning đầy đủ, ta đóng băng toàn bộ ma trận gốc W0 và gắn thêm hai ma trận nhỏ A và B song song với các lớp tuyến tính được chọn, để chúng học phần hiệu chỉnh ΔW = B × A. Biến thể QLoRA còn nén sẵn model gốc xuống 4 bit để model lớn vừa trên một GPU.

Vì chỉ A và B cần lưu gradient và trạng thái AdamW (thường chiếm dưới 1 đến 2 phần trăm số tham số), lượng bộ nhớ HBM (High Bandwidth Memory, bộ nhớ băng thông cao gắn trên GPU) khi huấn luyện giảm mạnh, và lượng tử hóa 4 bit của QLoRA giảm thêm phần lưu base. Khi phục vụ, có thể cộng gộp B × A vào W0 để chạy không tốn thêm độ trễ, hoặc giữ rời từng file adapter vài chục MB để dùng chung một model nền cho nhiều tác vụ.

Ví dụ đời thường: LoRA giống như chỉnh một cuốn sách giáo khoa dày 1.000 trang cho từng địa phương. Thay vì in lại cả cuốn cho mỗi tỉnh, bạn giữ nguyên cuốn gốc và chỉ in một tờ phụ lục mỏng dán chồng lên các mục cần đổi; sang tỉnh khác thì đổi tờ phụ lục. Ví dụ dừng lại ở chỗ: tờ phụ lục chỉ đúng khi dán lên đúng phiên bản sách mà nó được soạn cho, nên adapter không dùng được khi thiếu hoặc nhầm model gốc.

2Luồng

Sáu bước đầu là huấn luyện, bốn bước sau là phục vụ. Điểm đặc trưng của LoRA nằm ở chỗ chỉ A và B thay đổi; toàn bộ phần còn lại của luồng (dữ liệu, loss, prefill, decode) dùng lại nguyên của phương pháp mà adapter đang học. Chọn từng nút để mở bài liên quan.

Sơ đồ kiến trúc huấn luyện · 22 ô (1A → 5C)

Kiến trúc huấn luyện LLM · Ánh xạ với Bài Lab tổng hợp

Thứ tự đọc: 1A → 1B ở cột 1, 2A → 2D ở cột 2, 3A → 3E ở cột 3; mũi tên next batch từ 3E quay về cột 1 và mũi tên load weights đi xuống băng 5 (5A → 5C). Cột 4 không phải bước kế tiếp: 4A, 4B tiết kiệm bộ nhớ, còn 4C–4G là các phương pháp huấn luyện thay thế nhau. Di chuột hoặc bấm vào từng ô để đọc pop-over.

Tất cả (22)1. Dữ liệu & nhãn2. Forward3. Học từ sai số4. Quy mô & phương pháp5. Suy luận

Ẩn khung overlay

1A1B1C2A2B2C2D3A3B3C3D3E4A4B4C4D4E4F4G5A5B5C

4E4 · Scale & Training Methods

frozen W + B · A (hạng thấp r)

4E · LoRA / QLoRA

Đóng băng trọng số gốc và chỉ học hai ma trận nhỏ hạng thấp gắn thêm.

Nhận gì

Checkpoint nền (đóng băng) cùng dữ liệu của tác vụ mới, thường là cặp SFT.

Làm gì, vì sao

Thay vì sửa ma trận W lớn, đóng băng W và học thêm hai ma trận nhỏ A và B có hạng thấp r, dùng W + B·A. Chỉ A và B nhận gradient nên tiết kiệm bộ nhớ (không cần m, v cho toàn bộ W). QLoRA còn nén W xuống ít bit để tiết kiệm thêm.

Ra gì

Một cặp adapter nhỏ (A, B). Có thể gộp vào W để phục vụ không tốn thêm phép tính, hoặc giữ riêng để đổi adapter theo tác vụ.

Ví dụ, cách đọc ô

Nhãn ô: frozen W + B · A low-rank adapter. Với ma trận d × d và hạng r, adapter chỉ có 2·d·r tham số thay vì d². Với d = 16, r = 2 là 64 thay vì 256.

Lưu ý

Lợi thế chỉ có khi r nhỏ hơn nhiều so với d. LoRA là cách học bằng ít tham số, không bảo đảm bằng chất lượng tinh chỉnh toàn bộ.

Đọc bài 4E · LoRA / QLoRA↗Giai đoạn 10 trong Bài Lab: LoRA↗

flowchart TD
  step1["Nạp base và đóng băng toàn bộ W0"]
  step2["Gắn cặp adapter A, B vào các lớp đã chọn"]
  step3["Forward qua base cộng nhánh adapter"]
  step4["Tính loss của tác vụ đang giải"]
  step5["Backward và AdamW chỉ cho A, B"]
  step6["Lưu adapter nhỏ kèm metadata base và đánh giá"]
  step7["Phục vụ 1 · Nạp đúng base rồi gắn adapter"]
  step8["Phục vụ 2 · Merge vào base hoặc giữ rời"]
  step9["Phục vụ 3 · Prefill và decode không đổi"]
  step10["Phục vụ 4 · Đổi adapter theo từng request"]
  step1 --> step2
  step2 --> step3
  step3 --> step4
  step4 --> step5
  step5 --> step6
  step6 --> step7
  step7 --> step8
  step8 --> step9
  step9 --> step10

3Giải pháp

Bài toán: sửa mọi trọng số thì quá tốn và khó nhân bản

Với full fine-tuning, mỗi tham số cần trọng số, gradient và hai số của AdamW, nên huấn luyện một model lớn cần nhiều lần dung lượng bản thân model. Ngoài ra, mỗi tác vụ (tóm tắt, hỏi đáp pháp lý, sinh SQL) cho ra một bản sao đầy đủ hàng chục GB; chạy mười tác vụ nghĩa là giữ mười bản.

LoRA giải cả hai vấn đề cùng lúc bằng một giả định thực dụng: để chuyển model sang một tác vụ mới, phần cần thay đổi của mỗi ma trận trọng số có thể mô tả bằng rất ít thông tin. Ta chỉ học phần thay đổi nhỏ đó và giữ nguyên bản gốc dùng chung.

Khái niệm tối thiểu cần nắm trước khi đi vào các bước

Một lớp tuyến tính nhận vector đầu vào x và tính y = W·x, với W là ma trận có d_out hàng và d_in cột. Ma trận ΔW có cùng kích thước nhưng ta không lưu nó trực tiếp: ta lưu B có d_out hàng và r cột, A có r hàng và d_in cột, rồi lấy ΔW = B × A. Số r gọi là hạng (rank) và nhỏ hơn nhiều so với d_in và d_out, nên B × A tuy cùng kích thước với W nhưng chứa rất ít thông tin độc lập.

Tham số của adapter là r × (d_in + d_out). Ví dụ số cho một ma trận 4096 × 4096: base có 16.777.216 phần tử; với r = 8 adapter có 8 × (4096 + 4096) = 65.536 tham số, bằng khoảng 0,39 phần trăm base. Đây là phép đếm cho một ma trận, không phải tổng số tham số của cả LLM. Hệ số alpha/r nhân vào nhánh adapter để điều khiển độ mạnh của phần hiệu chỉnh; alpha là siêu tham số (hyperparameter, một số do người huấn luyện chọn) và công thức cụ thể có thể khác nhau tùy thư viện.

Ví dụ chạy xuyên suốt cả bài

Để theo dõi từng bước, ta dùng một lớp nhỏ tự bịa cho mục đích minh họa: d_in = d_out = 3, r = 1, alpha = 2 (nên hệ số alpha/r = 2). Ma trận gốc W0 là ma trận đơn vị, tức W0·x = x. Adapter có A = (1, 0, −1) là ma trận 1 hàng 3 cột và B là vector cột (0,1; 0; −0,1). Đầu vào là x = (1, 2, 3).

Bước huấn luyện 1 · Nạp base và đóng băng toàn bộ W0

Đầu vào là checkpoint gốc cùng tokenizer và config. Thao tác: nạp, rồi đánh dấu mọi ma trận gốc là không cần gradient (requires_grad bằng False). Lý do: đạo hàm và trạng thái AdamW của hàng tỷ tham số gốc chính là phần tốn bộ nhớ nhất, và đóng băng loại bỏ nó. Phải giữ đúng phiên bản base vì adapter chỉ có nghĩa trên chính base đã học nó; token ID và mặt nạ cũng phụ thuộc tokenizer và template tương thích.

Với QLoRA, base còn được nén xuống 4 bit ngay khi nạp, theo kiểu NF4 kèm double quantization. Ví dụ số minh họa: 7 tỷ tham số ở 16 bit tốn khoảng 14 GB (2 byte mỗi tham số), ở 4 bit tốn khoảng 3,5 GB (0,5 byte mỗi tham số) chưa kể một ít bộ nhớ cho các hệ số tỉ lệ. Cần phân biệt kiểu lưu (storage dtype, 4 bit) với kiểu tính (computation dtype, thường BF16): khi nhân ma trận, từng khối trọng số 4 bit được giải nén tạm về BF16. Nhiễu do lượng tử hóa là có thật, và adapter học để bù trong giới hạn của nó.

Đầu ra là model gốc sẵn sàng nhận adapter. Cách kiểm tra: ghi lại phiên bản base, tokenizer, config, dạng lưu (16 bit hay 4 bit) và xác nhận không có gradient hay trạng thái optimizer nào gắn với W0.

Bước huấn luyện 2 · Gắn cặp adapter A, B vào các lớp đã chọn

Thao tác gồm ba lựa chọn: lớp đích (target modules), rank r và hệ số alpha. Bài LoRA gốc gắn adapter vào các phép chiếu query và value của attention rồi đóng băng phần còn lại; bài QLoRA gắn vào mọi lớp tuyến tính để khớp chất lượng của huấn luyện 16 bit. Không có cấu hình nào đúng cho mọi model: hãy thử trên dữ liệu giữ riêng và ghi lại mọi lựa chọn, vì chỉ ghi tên LoRA thì kết quả không tái lập được.

Quy tắc khởi tạo chuẩn: A lấy giá trị ngẫu nhiên nhỏ, còn B bằng 0. Nhờ B = 0 nên ΔW = B × A bằng đúng 0 ở bước đầu, và mô hình xuất phát với hành vi giống hệt base. Ví dụ số khác để thấy lợi ích về kích thước: một ma trận 4096 × 11008 (thường gặp ở phần MLP của một số model) có 45.088.768 phần tử, adapter r = 8 chỉ có 8 × (4096 + 11008) = 120.832 tham số. Nếu một model có 32 lớp, mỗi lớp 4 ma trận 4096 × 4096 được gắn adapter với r = 8, thì có 32 × 4 × 65.536 = 8.388.608 tham số, tức khoảng 16 MiB nếu lưu 2 byte mỗi tham số (giả định để tính, model thật dùng kích thước khác nhau cho từng ma trận).

Rank lớn hơn nghĩa là nhiều tham số học hơn nhưng data và mục tiêu mới quyết định adapter học được gì; không nên gắn rộng rồi tự kỳ vọng chất lượng tăng.

Bước huấn luyện 3 · Forward qua base cộng nhánh adapter song song

Với mỗi lớp được gắn adapter, x đi qua hai nhánh cùng lúc: nhánh chính cho W0·x, nhánh phụ cho (alpha/r)·B·(A·x), rồi hai kết quả cộng theo từng phần tử. Quay lại ví dụ xuyên suốt: A·x = 1·1 + 0·2 + (−1)·3 = −2; B·(A·x) = (−0,2; 0; 0,2); nhân hệ số 2 được (−0,4; 0; 0,4). Đầu ra y = (1, 2, 3) + (−0,4; 0; 0,4) = (0,6; 2; 3,4). Khi B còn bằng 0 thì nhánh phụ bằng 0 và y = x = (1, 2, 3), đúng bằng base.

Có hai điều cần biết để đọc đúng chi phí. Thứ nhất, dữ liệu vẫn phải đi qua toàn bộ W0 nên số phép tính (FLOPs) của forward không giảm so với full fine-tuning; cái giảm là bộ nhớ cho gradient và optimizer. Thứ hai, các activation đưa tới nhánh A, B vẫn phải giữ lại cho backward. Cách kiểm tra: causal mask và kích thước tensor đúng như forward chuẩn (adapter không đổi kiến trúc attention), và loss khởi đầu phải khớp loss của base chưa gắn adapter. Xem lại cơ chế forward ở bài forward.

Bước huấn luyện 4 · Loss do tác vụ quyết định, không do LoRA định nghĩa

LoRA chỉ thay đổi cách biểu diễn phần cập nhật trọng số (ΔW = B × A), không định nghĩa hàm mất mát riêng. Vì thế bước này dùng lại nguyên loss của bài toán đang giải: cross-entropy có mặt nạ câu trả lời nếu là SFT, loss DPO hoặc loss thưởng nếu là căn chỉnh ưu tiên, hoặc loss khớp teacher nếu là distillation. Mọi quy tắc lọc dữ liệu, chat template và mặt nạ padding giữ nguyên.

Hệ quả thực tế: đừng đổ lỗi hay ghi công cho LoRA khi thứ quyết định kết quả là dữ liệu và loss. Hãy ghi rõ objective trước khi đọc kết quả adapter, và kiểm tra mặt nạ trên một batch nhỏ có padding và template thật; lỗi mặt nạ làm adapter học từ token rác và đó là lỗi của pipeline dữ liệu chứ không phải của phân rã hạng thấp.

Bước huấn luyện 5 · Backward và cập nhật chỉ cho A, B

Gradient vẫn phải chảy ngược xuyên qua các ma trận W0 đóng băng để đến được adapter ở các lớp sâu hơn, nhưng hệ thống bỏ qua việc tính và lưu gradient của chính W0. Do đó AdamW chỉ giữ hai số bổ sung cho mỗi tham số của A và B, tiết kiệm hàng chục GB trên model lớn. Trong QLoRA, paged optimizer cho phép mượn bộ nhớ thống nhất khi một batch có chuỗi dài làm bộ nhớ tăng vọt, thay vì làm chương trình dừng.

Một chi tiết hay bị bỏ qua: do B khởi tạo bằng 0 và gradient của A tỉ lệ với B, nên ở bước cập nhật đầu tiên gradient của A bằng 0 và chỉ B di chuyển. Khi B khác 0 thì A cũng bắt đầu học (riêng weight decay của AdamW vẫn có thể co A một chút ngay từ đầu). Không có gì sai ở đây; đó là hệ quả của việc khởi tạo B bằng 0.

Cách đọc: theo dõi gradient norm và độ lớn cập nhật của riêng adapter, vì norm của cả model bị phần đóng băng làm loãng. Khi báo cáo, số tham số huấn luyện được (trainable) và bộ nhớ optimizer là hai con số khác nhau; không cộng các moment của optimizer vào số tham số của model. Chi tiết về AdamW có ở bài AdamW.

Bước huấn luyện 6 · Lưu adapter nhỏ kèm metadata base, rồi đánh giá

Vì W0 không đổi so với lúc nạp, ta không cần lưu cả checkpoint hàng chục GB. Gói adapter chỉ gồm các tensor A, B đã học cùng một file cấu hình (thường tên adapter_config.json) ghi rank r, alpha, danh sách lớp đã gắn và định danh phiên bản base. Kích thước chỉ vài chục đến vài trăm MB tùy rank và số lớp, nên lưu hàng chục phiên bản theo tác vụ rất rẻ.

Gói này là weights-only: đủ để phục vụ, không đủ để huấn luyện tiếp. Resume cần thêm trạng thái optimizer, scheduler và bộ sinh số ngẫu nhiên. Adapter không tự chạy độc lập; nó và metadata base là một cặp không tách rời khi triển khai. Sau mỗi lần đóng gói hoặc đổi định dạng lưu, đo lại chất lượng: so base với base cộng adapter trên dữ liệu giữ riêng, kể cả khả năng chung, vì đổi runtime có thể làm lệch số.

Bước phục vụ 1 · Nạp đúng base rồi gắn adapter

Worker nạp base đúng phiên bản và tokenizer đã dùng lúc huấn luyện, rồi đọc gói adapter và gắn A, B lên đúng các lớp đã gắn khi huấn luyện. Vì A, B chỉ biểu diễn phần chênh lệch ΔW tính trên nền W0 ban đầu, gắn nhầm adapter lên một base khác (dù cùng số chiều) cho đầu ra lệch hoàn toàn mà thường không báo lỗi.

Do đó phải kiểm tra phiên bản base và adapter ngay lúc nạp, không để lỗi lọt tới request đầu tiên mới phát hiện, và log rõ cặp base-adapter đang phục vụ để gỡ lỗi hoặc quay lại phiên bản trước. Inference không nạp optimizer hay scheduler.

Bước phục vụ 2 · Gộp adapter vào base hoặc giữ rời

Hai lựa chọn triển khai. Gộp (merge): tính một lần W = W0 + (alpha/r)·B·A rồi dùng W như ma trận thường, nên không còn thêm độ trễ nào. Trong ví dụ xuyên suốt, (alpha/r)·B·A là ma trận với hàng một (0,2; 0; −0,2), hàng hai toàn 0, hàng ba (−0,2; 0; 0,2). Cộng với ma trận đơn vị và nhân với x = (1, 2, 3) cho (0,6; 2; 3,4), đúng bằng kết quả hai nhánh ở bước 3. Về lý thuyết hai đường tính cho cùng kết quả; trên số thực dấu phẩy động có thể lệch một chút do làm tròn, nên cần so logits trước và sau merge.

Giữ rời (unmerged): giữ W0 dùng chung và lưu từng cặp A, B riêng để mỗi lần forward cộng thêm nhánh B·(A·x). Chọn merge khi chỉ phục vụ một adapter và cần độ trễ thấp nhất; chọn giữ rời khi một base phục vụ nhiều tác vụ hoặc cần đổi adapter nhanh, hoặc khi base ở dạng lượng tử hóa không hỗ trợ cộng gộp trực tiếp (tài liệu PEFT ghi nhận giới hạn này ở một số định dạng). Ghi lựa chọn vào manifest triển khai vì nó đổi cả độ trễ lẫn bộ nhớ.

Bước phục vụ 3 · Prefill và decode chạy y như model nền

Sau khi trọng số sẵn sàng, quy trình suy luận giống hệt model nền: prefill điền KV cache và chọn token đầu, rồi decode sinh từng token. Các vector key/value ghi vào KV cache đã mang hiệu ứng của nhánh LoRA ở những lớp attention được gắn adapter, nhưng cấu trúc và dung lượng KV cache không đổi. Trọng số đứng yên suốt phục vụ và không có loss hay backward nào.

Vì vậy vận hành decode của LoRA bằng đúng playbook của model nền (chunked prefill, paged KV, batching) và đừng viết logic decode riêng. Nếu giữ adapter rời, phần overhead còn lại thuộc về nhánh B·(A·x) và cần đo riêng, không đổ cho KV hay scheduler. Xem prefill và decode.

Bước phục vụ 4 · Một base phục vụ nhiều adapter, đổi theo request

Lợi thế vận hành lớn nhất của LoRA là phục vụ đa tác vụ: thay vì thuê nhiều cụm GPU để nạp nhiều checkpoint đầy đủ, hệ thống giữ một bản W0 trên HBM cùng nhiều gói adapter nhẹ. Khi giữ adapter rời, các engine như vLLM hay SGLang dùng kernel chuyên biệt (như Punica hay S-LoRA) để tính chung W0·x cho cả batch gồm nhiều request, rồi rẽ nhánh tính riêng phần B_i·(A_i·x) theo adapter mà từng request yêu cầu. Adapter mới có thể được nạp lên base đang chạy mà không cần khởi động lại.

Rủi ro chính là định tuyến: nhầm adapter không báo lỗi mà chỉ cho đáp án của tác vụ khác, nên sau mỗi lần triển khai phải kiểm thử từng adapter trên prompt của nó. Số adapter chạy đồng thời bị giới hạn bởi bộ nhớ và độ trễ, cần đo thực tế. Đừng merge khi còn cần đổi nhanh giữa nhiều tác vụ.

Kết luận được rút ra và không được rút ra

Có thể kết luận: trên cùng một tác vụ và dữ liệu giữ riêng, base cộng adapter đạt kết quả đo được mà không cần cập nhật toàn bộ trọng số, và chi phí bộ nhớ huấn luyện nhỏ hơn full fine-tuning. Không thể kết luận: LoRA luôn ngang chất lượng full fine-tuning, rank nhỏ luôn đủ, hoặc một cấu hình tốt cho model này sẽ tốt cho model khác. Kết quả của QLoRA cũng không cho phép giả định mọi thao tác chạy ở 4 bit; chỉ phần lưu base ở 4 bit.

Thực hành trên Bài Lab tổng hợp

Giai đoạn 10 (LoRA) của Bài Lab tổng hợp cho bạn quan sát cùng một ý ở quy mô nhỏ: base đóng băng, adapter học, rồi gộp hoặc giữ rời. Trước khi chạy, hãy tự tính số tham số adapter bằng công thức r × (d_in + d_out) và so với số lab báo; sau đó kiểm tra rằng kết quả sau merge khớp kết quả khi giữ rời trong sai số số học.

4Profiling

• Tổng số tham số và tham số huấn luyện được

  Đếm riêng base và adapter, xác nhận base không có gradient và không được optimizer cập nhật. Ghi rank, lớp đích và hệ số alpha chứ không chỉ ghi tên LoRA.

• Bộ nhớ, chất lượng và phục vụ

  Đo bộ nhớ đỉnh gồm activation, trạng thái optimizer của adapter và base. So chất lượng trên dữ liệu giữ riêng giữa base và base cộng adapter; đo độ trễ khi giữ adapter rời và sau khi merge. Không đưa ra tuyên bố tăng tốc hoặc tiết kiệm nếu chưa đo trong cùng điều kiện.

• Tương đương trước và sau merge

  So logits hoặc kết quả sinh của đường giữ rời với đường đã gộp trên cùng đầu vào; sai khác phải nằm trong ngưỡng số học đã đặt trước. Với base lượng tử hóa, đây là kiểm tra bắt buộc.

• Định tuyến adapter

  Đảm bảo mọi request tới đúng cặp A, B của tác vụ nó, và đo overhead cùng bộ nhớ khi số adapter tăng.

Mẹo đo lường: ghim số liệu trên workload thật, ghi cả p50/p95/p99 thay vì chỉ trung bình, và luôn ghi lại điều kiện chạy (batch, cache, đồng thời, phần cứng) trước và sau khi tối ưu. Số đo thiếu điều kiện chạy thì không so sánh được.

5Ví dụ

6Thuật ngữ

Parameter-Efficient Fine-Tuning (PEFT)

Tinh chỉnh hiệu quả về tham số: chỉ cập nhật một phần rất nhỏ hoặc một module bổ sung, trong khi phần lớn trọng số gốc được giữ nguyên.

Low-Rank Adaptation (LoRA)

Thích nghi hạng thấp; phần thay đổi của một ma trận trọng số được biểu diễn bằng tích của hai ma trận nhỏ B và A.

QLoRA

Học adapter LoRA trên model gốc đã được lượng tử hóa xuống 4 bit, nhờ đó model lớn vừa trên một GPU.

Frozen base

Trọng số gốc W0 không nhận gradient và không đổi giá trị suốt quá trình huấn luyện.

Adapter (A, B)

Cặp ma trận nhỏ gắn song song với một lớp tuyến tính; A nén đầu vào xuống r chiều, B mở rộng lại về số chiều đầu ra.

Rank r

Số chiều "nút thắt" giữa A và B; r càng lớn thì adapter càng nhiều tham số và càng linh hoạt.

Scale alpha/r

Hệ số nhân của nhánh adapter, đặt bằng alpha chia cho r; công thức chi tiết có thể khác nhau tùy thư viện.

Target modules

Các lớp tuyến tính được gắn adapter, ví dụ các phép chiếu query và value trong attention hoặc mọi lớp tuyến tính.

NF4 và double quantization

NF4 là kiểu số 4 bit NormalFloat thiết kế cho trọng số có phân phối gần chuẩn; double quantization lượng tử hóa tiếp các hệ số tỉ lệ để giảm thêm bộ nhớ.

Paged optimizer

Cơ chế mượn bộ nhớ thống nhất (unified memory) khi GPU tạm hết chỗ, tránh dừng chương trình lúc bộ nhớ tăng vọt.

Adapter artifact

File lưu A, B cùng metadata (rank, alpha, lớp đích, phiên bản base); không chạy được nếu thiếu đúng base.

Merge (gộp adapter)

Tính một lần W = W0 + (alpha/r)·B·A rồi dùng W như một ma trận thường, không còn nhánh phụ.

Multi-LoRA serving

Giữ một model gốc trên GPU cùng nhiều adapter rời và chọn adapter theo từng request.

7Bài liên quan

8Nguồn