Một triệu token không hề “ảo”

Giả sử bạn đang nói chuyện với một AI.

Bạn gửi cho nó 10 dòng code.

Rồi 100 dòng.

Rồi nguyên repository.

Rồi vài trăm file log.

Rồi một đống tài liệu dài tới mức nếu đem in ra giấy chắc đủ kê chân một cái bàn đang bị cập kênh.

Trên màn hình, mọi thứ vẫn rất nhẹ nhàng.

Bạn chỉ thấy một ô chat.

Một con trỏ nhấp nháy.

Một nút Send.

Nhưng bên dưới cái nút Send ấy không có gì là hoàn toàn ảo.

Một triệu token không phải một triệu linh hồn bay lơ lửng trong cloud.

Chúng trở thành tensor thật.

Tensor nằm trong bộ nhớ thật.

Bộ nhớ nằm trên những con chip thật.

Những con chip đó phải đọc dữ liệu, nhân ma trận, truyền hàng tỷ byte qua những đường bus có giới hạn băng thông rất thật.

Và đây chính là lúc một trong những thứ đẹp nhất của Transformer bắt đầu trở thành một trong những thứ phiền nhất của nó:

Attention nhớ quá nhiều.

Kimi Delta Attention, hay KDA, được Moonshot AI xây dựng để xử lý chính bài toán này. Nó là thành phần trung tâm của kiến trúc Kimi Linear và sau đó tiếp tục trở thành một trong những nền móng của Kimi K3 — mô hình 2.8 nghìn tỷ tham số với 104 tỷ tham số được kích hoạt mỗi token và context window lên tới 1 triệu token. (arXiv)

Nhưng để hiểu KDA, trước tiên chúng ta phải hiểu tại sao một con AI lại cần một cái nhà kho khổng lồ chỉ để nhớ những gì vừa đọc.

Attention giống một đứa trẻ không chịu vứt giấy nháp

Giả sử một đứa trẻ ngồi học toán.

Mỗi lần cô giáo nói một câu, nó ghi câu đó lên một tờ giấy.

Câu thứ nhất:

Nam có 5 quả táo.

Nó giữ tờ giấy.

Câu thứ hai:

Nam cho Lan 2 quả.

Nó lại lấy thêm một tờ giấy.

Câu thứ ba, câu thứ tư, câu thứ năm…

Nó không vứt bất cứ thứ gì.

Đến cuối buổi học, muốn trả lời câu hỏi:

Nam còn bao nhiêu quả táo?

Nó chạy qua toàn bộ đống giấy, xem tờ nào liên quan rồi mới trả lời.

Đó là một cách lúa hóa khá sát với self-attention.

Mỗi token tạo ra ba thứ quen thuộc:

• Query
• Key
• Value

Có thể hình dung đơn giản:

• Key: cái nhãn dán trên tờ giấy.
• Value: nội dung được viết trên tờ giấy.
• Query: câu hỏi hiện tại đang muốn tìm loại giấy nào.

Khi sinh token tiếp theo, Transformer lấy Query hiện tại đi so với các Key trong quá khứ, tìm ra những phần quan trọng, sau đó lấy các Value tương ứng ra sử dụng.

Ý tưởng này cực kỳ mạnh.

Token hiện tại có thể trực tiếp nhìn về token rất xa trong quá khứ.

Không cần chuyền ký ức qua từng bước giống RNN cổ điển.

Nhưng vấn đề cũng nằm ngay trong chữ toàn bộ.

Context dài ra bao nhiêu thì quá khứ cần giữ lại cũng dài ra bấy nhiêu.

Trong inference autoregressive, hệ thống thường giữ các Key và Value đã tính trong một vùng bộ nhớ gọi là KV cache.

10 token thì chẳng có gì đáng nói.

10.000 token bắt đầu đáng nói.

100.000 token thì GPU bắt đầu nhíu mày.

1.000.000 token thì câu chuyện trở thành một bài toán kiến trúc hệ thống.

KV cache: cái nhà kho cứ dài ra mãi

Với full attention truyền thống, số token tăng lên kéo theo hai vấn đề khác nhau.

Thứ nhất là tính toán attention.

Nếu xét một phép self-attention đầy đủ trên chuỗi dài $N$, ma trận attention có kích thước gần với:

$$ N \times N $$

Do đó chi phí tính toán truyền thống có thành phần tăng theo:

$$ O(N^2) $$

Gấp đôi chiều dài sequence không có nghĩa là chỉ làm gấp đôi công việc.

Trong phần attention đầy đủ, nó có thể tiến gần tới gấp bốn.

Thứ hai là KV cache khi decode.

Khi model sinh token thứ:

11
22
33
44
5...
6999999
71000000

nó không muốn tính lại Key và Value của 999.999 token trước.

Vì vậy nó giữ chúng lại.

Context càng dài, KV cache càng lớn.

Tức là bộ nhớ dành cho quá khứ tăng gần tuyến tính theo chiều dài sequence.

Đây chính là thứ các kiến trúc linear attention muốn thay đổi.

Thay vì:

1quá khứ
2→ giữ token 1
3→ giữ token 2
4→ giữ token 3
5→ ...
6→ giữ token thứ 1.000.000

ta thử làm chuyện nghe hơi kỳ quặc hơn:

1quá khứ
2→ nén thành một trạng thái S
3→ token mới tới
4→ sửa S
5→ token mới tới
6→ sửa S
7→ token mới tới
8→ lại sửa S

Không còn một nhà kho dài vô tận.

Chỉ còn một cái bảng trắng.

Linear Attention: đừng giữ cả lịch sử, hãy giữ một bản tóm tắt đang sống

Ý tưởng chung của recurrent linear attention là biến quá khứ thành một state có kích thước cố định.

Gọi state đó là:

$$ S_t $$

Tại thời điểm $t$, model có:

• key $k_t$
• value $v_t$
• query $q_t$

Một linear attention đơn giản có thể cập nhật:

$$ S_t = S_{t-1} + k_t v_t^T $$

và đọc:

$$ o_t = S_t^T q_t $$

Nhìn công thức hơi đáng sợ nhưng câu chuyện rất đơn giản.

Token mới tới.

Nó không được bỏ nguyên xi vào nhà kho.

Thông tin của nó được trộn vào cái bảng nhớ hiện tại.

Muốn lấy thông tin ra thì Query đọc từ cái bảng đó.

Kích thước $S$ không phụ thuộc trực tiếp vào việc chúng ta đã đọc 1.000 hay 1.000.000 token.

Đây là lý do linear attention có thể được biểu diễn dưới dạng một RNN với matrix-valued hidden state và tránh KV cache tăng không ngừng như full attention. (arXiv)

Nghe ngon.

Xong thuật toán.

Quá dễ.

Tất nhiên là không.

Nếu dễ vậy thì Transformer đã về hưu từ lâu.

Vấn đề của một cái bảng trắng: ghi mãi rồi nó thành cháo

Hãy tưởng tượng cái bảng trắng trong lớp học.

Buổi sáng viết:

1Nam có 5 quả táo

Một lúc sau viết:

1Lan có 3 quả cam

Rồi:

1Nam đưa Lan 2 quả táo

Rồi:

1Lan đi mua sữa

Rồi:

1Nam đổi tên thành Bình

Nếu cứ cộng mọi thứ lên bảng mà không xóa, không sửa và không biết chỗ nào đã lỗi thời, cuối ngày cái bảng sẽ giống một tô mì.

Đó cũng là một trong những khó khăn của linear attention.

Bộ nhớ có kích thước hữu hạn.

Nó phải chứa một dòng thông tin gần như vô hạn.

Vấn đề không còn chỉ là:

Làm sao ghi?

Mà là:

Ghi cái mới vào thì phải xử lý cái cũ như thế nào?

Đây là nơi Delta Rule xuất hiện.

Delta Rule: trước khi ghi, hãy xem mình đang nhớ sai cái gì

Giả sử trong trí nhớ hiện tại:

1Nam → 5 quả táo

Sau đó ta nhận được thông tin mới:

1Nam → 3 quả táo

Một cách ngây thơ là cộng thêm:

1Nam → 5
2Nam → 3

Và hy vọng tương lai tự hiểu.

Delta Rule làm một việc thông minh hơn.

Nó hỏi bộ nhớ trước:

Hiện tại nếu tôi tra “Nam”, anh trả lời bao nhiêu?

Giả sử state trả lời:

15

Nhưng target mới là:

13

Ta có sai số:

$$ \Delta = 3 - 5 = -2 $$

Thay vì viết thêm nguyên một bản ghi mới, model sử dụng sai số đó để sửa bộ nhớ hiện tại.

Trong dạng đơn giản:

$$ \delta_t = v_t - S_{t-1}^T k_t $$

sau đó:

$$ S_t = S_{t-1} + \beta_t k_t \delta_t^T $$

Trong đó $\beta_t$ kiểm soát mức độ mạnh yếu của lần sửa.

Nói bằng tiếng người:

1đọc ký ức hiện tại
2→ xem nó sai bao nhiêu
3→ sửa phần sai
4→ đưa ký ức tiến gần thông tin mới

DeltaNet vì vậy có thể được nhìn như một dạng associative memory tự sửa chính mình, thay vì một cái thùng chỉ biết nhét thêm dữ liệu. Các nghiên cứu về DeltaNet mô tả phép cập nhật này như một bước online gradient descent trên bài toán ánh xạ key sang value. (arXiv)

Nhưng vẫn còn một vấn đề.

Con người không chỉ biết sửa.

Con người còn biết quên.

Gated DeltaNet: trí nhớ cần một cái nút quên

Giả sử hôm qua tôi nói:

1Tôi đang ở Hà Nội.

Hôm nay tôi nói:

1Tôi đã bay vào TP.HCM.

Thông tin hôm qua không sai.

Nó chỉ hết hạn.

Đây là thứ mà một hệ thống memory cần xử lý.

Gated DeltaNet bổ sung một forget gate, có thể hình dung như:

$$ \alpha_t $$

với:

$$ 0 < \alpha_t < 1 $$

Một dạng cập nhật có thể viết:

$$ S_t = \alpha_t (I-\beta_t k_tk_t^T) S_{t-1} + \beta_t k_tv_t^T $$

Nếu:

$$ \alpha_t \approx 1 $$

thì ký ức cũ gần như được giữ lại.

Nếu:

$$ \alpha_t \approx 0 $$

thì quá khứ bị quên rất mạnh.

Nhưng ở đây lại xuất hiện một chi tiết thú vị.

Gated DeltaNet dùng một mức decay tương đối thô ở phạm vi head.

Tưởng tượng một cái bảng có 64 cột nhưng chúng ta chỉ có một nút:

1QUÊN

Bấm nó xuống thì 64 cột cùng mờ đi.

Nhưng trong thực tế, có thể:

1cột tên người      → cần nhớ
2cột địa điểm       → cần quên
3cột thời gian      → quên một chút
4cột chủ đề         → giữ gần nguyên

Tại sao tất cả phải quên với cùng một tốc độ?

Kimi Delta Attention thay đổi chính điểm này.

Kimi Delta Attention: mỗi phần của ký ức được quyền quên khác nhau

Điểm quan trọng nhất của KDA nghe khá nhỏ:

thay forget gate dạng scalar bằng channel-wise decay.

Thay vì:

$$ \alpha_t $$

ta có một vector:

$$ \boldsymbol{\alpha}_t $$

và tạo một ma trận đường chéo:

$$ D_t = \operatorname{Diag}(\boldsymbol{\alpha}_t) $$

Khi đó một cách biểu diễn KDA là:

$$ S_t = (I-\beta_t k_tk_t^T) D_tS_{t-1} + \beta_t k_tv_t^T $$

(arXiv)

Công thức nhìn như con nhện bò qua bàn phím.

Nhưng ý tưởng lại rất đẹp.

Hãy tưởng tượng memory state có nhiều ngăn:

1[ngăn 1] [ngăn 2] [ngăn 3] [ngăn 4] ...

KDA có thể học:

1ngăn 1: giữ 99%
2ngăn 2: giữ 71%
3ngăn 3: giữ 12%
4ngăn 4: giữ 94%

thay vì:

1mọi ngăn: giữ 71%

Đó là fine-grained gating.

Paper Kimi Linear mô tả KDA là phần mở rộng của Gated DeltaNet, trong đó cơ chế gating được làm chi tiết hơn để sử dụng hiệu quả hơn bộ nhớ RNN hữu hạn. (arXiv)

Nói cách khác, KDA không tạo ra trí nhớ vô hạn.

Nó làm một việc khó hơn:

học cách sống với một trí nhớ hữu hạn.

Và đó có lẽ mới là phần thú vị nhất.

Full Attention và KDA khác nhau ở triết lý nhớ

Ta có thể hình dung hai thế giới.

Full Attention:

1Tôi không biết sau này cần gì.
2Vậy nên tôi giữ gần như mọi thứ.

KDA:

1Tôi không thể giữ mọi thứ.
2Vậy tôi phải học cách nén,
3học cách sửa,
4học cái gì nên giữ,
5và học cái gì phải quên.

Một bên giống thư viện.

Một bên giống trí nhớ.

Thư viện có thể giữ nguyên cuốn sách số 73.428 trên kệ rồi 10 năm sau lấy đúng nó xuống.

Trí nhớ con người thì không như vậy.

Chúng ta không lưu nguyên xi hình ảnh bữa cơm trưa ngày 17 tháng trước ở dạng PNG 8K.

Não giữ lại một trạng thái đã được nghiền, trộn, quên, nhấn mạnh và tái cấu trúc.

KDA tất nhiên không phải bộ não người.

Nhưng về mặt trực giác, cách quản lý thông tin của nó gần với ý tưởng memory state động hơn là một kho dữ liệu chỉ append.

Tại sao Kimi không bỏ full attention hoàn toàn?

Đây là một chi tiết rất đáng chú ý.

Nếu KDA ngon như vậy, tại sao không thay tất cả attention bằng KDA?

Bởi vì nén luôn có cái giá của nén.

Giả sử tôi đưa cho bạn 10.000 trang sách và yêu cầu:

Hãy tóm tắt tất cả vào một tờ A4.

Bạn hoàn toàn có thể làm.

Nhưng sau đó tôi hỏi:

Ở trang 7.431, dòng thứ 12, tác giả dùng từ gì?

Khả năng cao chúng ta có chuyện để nói.

Full attention có một sức mạnh rất khó thay thế:

truy cập trực tiếp quá khứ.

KDA thì ép lịch sử đi qua một state hữu hạn.

Vì vậy Kimi Linear sử dụng kiến trúc hybrid.

Moonshot công bố tỷ lệ:

13 KDA
2:
31 MLA

tức khoảng ba lớp KDA xen với một lớp global Multi-Head Latent Attention.

KDA xử lý phần lớn sequence theo cách tuyến tính và tiết kiệm bộ nhớ.

MLA thỉnh thoảng xuất hiện như một cửa sổ để model quay lại nhìn trực tiếp toàn bộ context.

Theo báo cáo Kimi Linear, kiến trúc này có thể giảm KV cache tới khoảng 75% và trong benchmark của nhóm nghiên cứu đạt tốc độ decode cao hơn tới khoảng 6 lần ở context 1 triệu token so với kiến trúc MLA đầy đủ trong cấu hình so sánh của họ. (arXiv)

Đây là một thiết kế rất thực dụng.

Không cực đoan kiểu:

Linear Attention sẽ tiêu diệt Transformer.

Mà giống:

Cái gì đắt thì dùng ít lại. Cái gì rẻ thì bắt nó gánh phần lớn công việc.

KDA không chỉ là công thức toán, nó còn phải chạy được trên GPU

Có một căn bệnh khá phổ biến trong machine learning research.

Paper viết:

1O(N)

Mọi người vỗ tay.

Đem lên GPU chạy:

1chậm hơn O(N²)

Mọi người đi ngủ.

Lý do là Big-O không kể cho ta nghe toàn bộ câu chuyện vật lý.

GPU thích:

• phép toán lớn,
• song song,
• truy cập memory liên tục,
• kernel được tối ưu tốt.

GPU ghét:

• hàng triệu phép cập nhật nhỏ tuần tự,
• branching,
• memory access lung tung,
• kernel launch lắt nhắt.

Trong dạng recurrent thuần túy:

1S1
2→ S2
3→ S3
4→ S4
5→ ...

ta lại tạo ra dependency theo thời gian.

Token sau cần state của token trước.

Một CPU có thể nhìn chuyện này rồi nói:

Bình thường mà.

Một GPU có hàng nghìn core nhìn vào sẽ hỏi:

Rồi mấy đứa còn lại ngồi uống trà hả?

Vì vậy phần quan trọng của Kimi Linear không chỉ là recurrence.

Moonshot còn xây dựng chunkwise algorithm và kernel chuyên dụng để song song hóa quá trình training, sử dụng cấu trúc transition kiểu Diagonal-Plus-Low-Rank nhằm giảm chi phí tính toán mà vẫn giữ được tính chất của delta rule. (arXiv)

Đây là chỗ machine learning chạm thẳng vào system engineering.

Một công thức toán có thể đẹp.

Nhưng muốn biến nó thành LLM hàng nghìn tỷ tham số, nó phải đi qua:

1toán học
2→ tensor layout
3→ kernel
4→ GPU
5→ HBM
6→ interconnect
7→ distributed training
8→ inference engine

Không có đoạn nào là ảo.

Rồi Kimi K3 xuất hiện

Kimi Linear ban đầu là nơi Moonshot chứng minh KDA có thể hoạt động ở quy mô lớn.

Đến Kimi K3, ý tưởng đó được đẩy xa hơn.

Kimi K3 có:

• khoảng 2.8 nghìn tỷ tham số tổng cộng,
• khoảng 104 tỷ tham số active mỗi token,
• 16 expert được kích hoạt trong tổng số 896 routed experts,
• native multimodal,
• context window 1 triệu token.

Kiến trúc của K3 tiếp tục sử dụng Kimi Delta Attention cùng Attention Residuals để cải thiện dòng thông tin theo cả chiều sequence lẫn chiều sâu model. (arXiv)

Điều đáng chú ý không phải KDA tự mình tạo ra K3.

K3 còn có MoE, quantization-aware training, hệ thống expert parallel, Attention Residuals và cả một đống engineering phía dưới.

Nhưng việc Moonshot tiếp tục đặt KDA ở trung tâm của một model 2.8T cho thấy linear attention không còn chỉ là một món đồ chơi học thuật kiểu:

1chạy thử trên model 125M
2→ biểu đồ đẹp
3→ hết paper

Nó đã bước vào một kiến trúc frontier model thực sự.

Nhưng KDA không phải phép thuật

Ở đây cần đập nhẹ một cái thắng.

KDA giải quyết rất tốt một loại vấn đề, nhưng không biến memory hữu hạn thành memory vô hạn.

Đó là điều bất khả thi nếu ta muốn giữ toàn bộ thông tin chính xác tuyệt đối.

KDA vẫn có những trade-off.

Bộ nhớ bị nén

Full attention giữ các Key và Value riêng biệt của quá khứ.

KDA ép lịch sử vào state cố định.

Khi nhiều thông tin cạnh tranh nhau, interference vẫn có thể xảy ra.

Quên cũng có thể quên nhầm

Channel-wise decay giúp việc forgetting chi tiết hơn.

Nhưng model vẫn phải học nên quên gì.

Không có ông thần nào ngồi trong GPU chỉ tay:

1cái này quan trọng
2cái kia bỏ

Delta Rule vẫn còn coupling

Trong KDA hiện tại, hệ số $\beta_t$ vẫn tham gia vào cả phần corrective erase và write.

Các nghiên cứu tiếp theo như Gated DeltaNet-2 đã chỉ ra hạn chế này và đề xuất tách điều khiển erase và write thành các gate khác nhau. (arXiv)

Điều đó khá thú vị.

KDA không phải điểm kết thúc.

Nó là một bước trong quá trình tiến hóa của một câu hỏi lớn hơn:

Nếu AI chỉ có một lượng memory hữu hạn, nó nên quản lý memory đó như thế nào?

Một ví dụ nhỏ

Giả sử memory của một model chỉ có ba channel tượng trưng:

1A = con người
2B = địa điểm
3C = thời gian

State hiện tại đại khái chứa:

1Tùng
2Hà Nội
3hôm qua

Token mới nói:

1Tùng đang ở TP.HCM hôm nay.

Một forget gate kiểu coarse có thể tạo:

1alpha = 0.7

Tức là:

1con người  × 0.7
2địa điểm   × 0.7
3thời gian  × 0.7

Nhưng thứ cần thay đổi mạnh thực ra chỉ là địa điểm và thời gian.

KDA có thể học một vector kiểu:

1alpha =
2[
3    0.99,   # tên người: giữ
4    0.10,   # địa điểm: quên mạnh
5    0.05    # thời gian: quên mạnh
6]

Sau decay:

1Tùng      → gần như nguyên
2Hà Nội    → mờ đi
3hôm qua   → gần biến mất

Sau đó delta update ghi:

1TP.HCM
2hôm nay

Đây không phải cách implement thực tế theo nghĩa các channel thật sự tương ứng trực tiếp với “người”, “địa điểm”, “thời gian”.

Neural network không chia tensor đẹp đẽ cho chúng ta như Excel.

Ví dụ trên chỉ để hình dung bản chất:

mỗi chiều của memory có thể có tốc độ decay khác nhau.

Điều thú vị nhất của KDA không phải chữ Linear

Nếu chỉ nhìn benchmark, ta dễ tóm KDA thành:

1attention nhanh hơn
2KV cache nhỏ hơn
3context dài hơn

Đúng.

Nhưng hơi phí.

Theo mình, điều thú vị hơn nằm ở một chuyển dịch tư duy.

Transformer cổ điển phần nào giải quyết memory bằng cách nói:

Không biết cái gì sẽ quan trọng, vậy giữ quá khứ lại.

KDA nói:

Không thể giữ quá khứ mãi, vậy phải học cách quản lý quá khứ.

Đây là hai triết lý hoàn toàn khác nhau.

Một bên dùng storage.

Một bên dùng state.

Một bên mua thêm nhà kho.

Một bên học cách dọn nhà.

Và lịch sử ngành máy tính có một trò khá buồn cười.

Mỗi lần hardware lớn lên, chúng ta lại nghĩ:

Cuối cùng memory đủ rồi.

Rồi software lập tức nghĩ ra cách ăn hết nó.

RAM tăng.

Dataset tăng.

VRAM tăng.

Model tăng.

Context tăng.

KV cache tăng.

Cuối cùng chúng ta lại đứng trước cái máy có hàng trăm GB HBM và hỏi:

Có cách nào dùng ít memory hơn không?

Con người quả là một loài rất kiên định.

Có thể KDA báo trước một hướng đi lớn hơn

Trong nhiều năm, phần lớn LLM dựa vào một nguyên tắc tương đối đơn giản:

1context dài hơn
2→ giữ nhiều token hơn
3→ attention trên nhiều token hơn

Nhưng context đang tiến từ:

14K
232K
3128K
41M
5...

Nếu tiếp tục tư duy mọi thông tin đều phải nằm nguyên xi trong KV cache, chi phí vật lý sẽ ngày càng khó chịu.

Có thể tương lai sẽ không chỉ là:

1context lớn hơn

mà là:

1memory thông minh hơn

Một model có thể có nhiều tầng nhớ:

1local attention
2        ↓
3recurrent state
4        ↓
5compressed memory
6        ↓
7retrieval
8        ↓
9external storage

Thông tin vài giây trước được giữ rất rõ.

Thông tin vài phút trước bị nén.

Thông tin vài ngày trước chuyển sang external memory.

Thông tin không còn hữu ích bị quên.

Nghe hơi giống con người.

Chúng ta cũng không nhớ từng pixel của mọi thứ từng nhìn thấy.

Nếu nhớ như vậy có khi 5 tuổi đã hết RAM.

Tổng kết

Kimi Delta Attention không đơn giản là một phiên bản attention có Big-O đẹp hơn.

Ý tưởng của nó có thể tóm lại thành bốn bước:

1đọc memory
2→ quên có chọn lọc
3→ sửa phần đang sai
4→ ghi thông tin mới

Thay vì giữ một KV cache tăng mãi theo sequence, KDA sử dụng một recurrent state có kích thước cố định theo chiều dài context. So với Gated DeltaNet, nó làm forget gate chi tiết hơn bằng channel-wise decay, cho phép các chiều của memory quên với tốc độ khác nhau.

Kimi Linear sau đó kết hợp KDA với global MLA theo kiến trúc hybrid, dùng linear attention cho phần lớn công việc nhưng vẫn giữ các lớp full attention để truy cập trực tiếp quá khứ khi cần. (arXiv) Moonshot tiếp tục mang KDA vào Kimi K3 ở quy mô 2.8 nghìn tỷ tham số và context 1 triệu token. (arXiv)

Có một nghịch lý khá đẹp ở đây.

Chúng ta thường nghĩ trí thông minh đến từ khả năng nhớ nhiều hơn.

Nhưng đôi khi, thứ làm một hệ thống thông minh hơn lại là khả năng biết:

cái gì đáng nhớ, cái gì phải sửa, và cái gì nên quên đi.

Cảm ơn các bạn đã quan tâm và theo dõi bài viết, hẹn gặp lại ở các bài viết tiếp theo.

Tham khảo

• Kimi Linear: An Expressive, Efficient Attention Architecture
• MoonshotAI/Kimi-Linear
• Kimi K3: Open Frontier Intelligence
• Kimi K3 Technical Blog
• Gated Delta Networks: Improving Mamba2 with Delta Rule
• Parallelizing Linear Transformers with the Delta Rule over Sequence Length
• Gated DeltaNet-2: Decoupling Erase and Write in Linear Attention