寫進裸盤的三百億個引數 左邊是把權重直接 dd 到 /dev/nvme1n1 的命令和引數個數 30,532,122,624;右邊一根 M.2 固態盤上方放大出快閃記憶體單元的網格,其中幾個亮起的單元伸出彎曲的連線,匯聚到一個像神經元胞體的圓點上。 $ dd if=qwen3-30b-a3b-q4.bin \ of=/dev/nvme1n1 oflag=direct 30,532,122,624 個引數,沒有檔名,沒有目錄 LBA 0 … 3,727,067

Qwen3-30B-A3B 有 30,532,122,624 個引數1,用 BF16 存是 61 GB,量化到 4 位約 15 GB。假設我們已經把量化好的權重拼成了一個連續的二進位制檔案,拿一塊新盤,不分割槽、不格式化,直接把它寫進去:

Terminal window
dd if=qwen3-30b-a3b-q4.bin of=/dev/nvme1n1 bs=4M oflag=direct

寫完以後,這塊盤上沒有檔名,也沒有目錄。從第 0 個扇區開始,就是這三百億個數。拔掉電源放進抽屜,一年後插上,它們還在。

我們常說,大腦的長期記憶存在突觸的強度裡,而突觸強度也是一個能保持很久的物理量。一個 4 位的權重和一個突觸的強度,看起來都是“用一個物理量存住的一個數”。於是就有了下面幾個問題:

  1. 沒有檔案系統時,這 30B 個引數在盤上是什麼形態?落到物理介質上,它們和突觸有多像?
  2. 盤裡存著這些數,算不算像神經元那樣“記住”了?兩種記憶差在哪裡?
  3. 不把引數全部搬進記憶體,直接從盤上邊讀邊用,30B 能跑多快?
  4. 能不能讓盤裡的儲存單元自己參與計算,甚至像突觸一樣邊用邊學?
  5. 如果真要把 30B 引數固化到盤上,什麼樣的模型、什麼樣的盤最合適?

本文就順著這五個問題,一層一層往下講。


一、裸盤上的三百億個數

沒有檔案系統,盤就是一個大陣列

在 Linux 下,一塊不分割槽、不格式化的盤,就是 /dev/nvme1n1 這樣一個塊裝置。對程式來說它只有一個屬性:大小。讀寫時給出偏移量和長度,盤就把那一段位元組交出來;偏移量除以扇區大小(今天的盤多是 4 KiB),就是 LBA(邏輯塊地址)。

檔案系統是在這個大陣列上又加的一層:檔名、目錄、許可權,以及“這個檔案的第 N 個位元組在盤上哪裡”的對映表。去掉檔案系統,名字沒了,但偏移量本身就是地址,不需要再查表。

對模型權重來說,名字這一層本來就可有可無。一個模型是一組形狀和順序都固定的張量。常見的 safetensors 格式,本身就是一個 JSON 頭加一段連續的原始位元組,頭裡記著每個張量的形狀和起止偏移2。把它鋪到裸盤上,什麼都不會丟。

以 Qwen3-30B-A3B 為例。它有 48 層,每層 128 個專家,每個專家是三個矩陣:gate_proj 和 up_proj 是 768×2048,down_proj 是 2048×7681。一個專家共 4,718,592 個引數,按 4 位存是 2,359,296 位元組,正好 576 個 4 KiB 扇區(為了算得整齊,這裡不計量化格式裡的縮放因子,實際的 4 位格式每個引數還要多出零點幾位)。把專家按“層號、專家號”的順序依次排好,第 layer 層第 e 個專家的位置就是:

offset = (layer × 128 + e) × 2,359,296

要讀第 0 層的 1 號專家,算出 LBA 576,連續讀 576 個扇區就行。

一個專家的權重怎樣落到裸盤上 第 0 層 1 號專家的三個矩陣按 4 位存共 2,359,296 位元組,按公式算出偏移量,除以 4096 得到 LBA 576;在裸裝置上,專家按層號和專家號依次排開;SSD 內部再由 FTL 把 LBA 576 到 1151 對映到某顆晶片某個塊的第 88 到 231 頁,這一層主機看不到。 一個專家的權重(4 位) 主機按公式算地址,不查表 裸裝置 /dev/nvme1n1 · 4 KiB 扇區 SSD 內部 · FTL(主機看不到) 專家 layers.0.experts.1 gate_proj768×2048786,432 B up_proj768×2048786,432 B down_proj2048×768786,432 B 合計2,359,296 B = 576 扇區 偏移量 offset = (layer×128 + e) × 2,359,296 layer = 0, e = 1 offset = 2,359,296 LBA = offset ÷ 4096 = 576 L0 · E0LBA 0 L0 · E1LBA 576 L0 · E2LBA 1,152 L0 · E3LBA 1,728 … L0 · E127LBA 73,152 L1 · E0LBA 73,728 … LBA 576–1151 → 晶片 2 · 塊 1,407 · 頁 88–231 虛線:控制器內部的對映(示意),會隨垃圾回收改變
圖 1 · 去掉檔案系統,偏移量就是地址:主機按公式算出 LBA 直接讀。但 SSD 的 LBA 只是邏輯地址,底下還有一層主機看不到的對映。

不過,“裸”只裸到介面這一層。在 SSD 裡,LBA 只是一個邏輯地址:快閃記憶體不能原地改寫,只能按頁(常見 16 KiB)寫、按塊擦,所以控制器內部維護一張 FTL(快閃記憶體轉換層)對映表,把每個 LBA 對映到某顆晶片、某個塊、某一頁,並且在垃圾回收和磨損均衡時不斷搬動資料3。機械硬碟好一些,LBA 基本按順序對應到磁軌上的扇區,只有壞扇區會被重對映到備用區。所以,裸盤給主機的是一個平整的地址空間,但底下的介質並不長這個樣子。

一個儲存單元能存多少

再往下一層,到一個儲存單元。今天的大容量 SSD 多用 QLC 快閃記憶體:每個單元是一個浮柵(或電荷俘獲)電晶體,裡面存著一些電荷,電荷多少決定了它的閾值電壓。閾值電壓是一個連續量,控制器把它劃成 16 個視窗,於是一個單元能存 4 位。

按數量算,一個 4 位權重剛好對應一個 QLC 單元。30.5B 個引數就是 30.5B 個單元;一塊 1 TB 的 QLC 盤大約有 2×10¹² 個單元,這個模型只佔其中的 1.5%。

突觸這邊,有一項研究用電鏡重建了大鼠海馬裡的突觸,按突觸的大小估計,它們大約能區分出 26 檔強度,摺合約 4.7 位元4。兩邊驚人地接近:都是一個斷電後仍然保持的模擬量,都被分成了十幾二十檔,大約 4 位元。

但盤並不讓“一個權重的值”等於“一個單元的電荷量”。控制器寫入之前,先把資料和一段偽隨機序列做異或(加擾),避免全 0、全 1 這類圖案加重單元之間的干擾,再加上 ECC 校驗位。而在 QLC 的一條字線上,一個單元的 4 位分屬 4 個不同的頁,同一頁裡相鄰的位落在相鄰的單元裡3。結果是:一個權重的 4 位分散在 4 個單元裡,每個單元又混著另外 3 頁裡不相干的資料。

一個 4 位權重在 QLC 快閃記憶體裡的樣子 權重 −0.0126 量化成 4 位碼 0101,控制器加擾後變成 0011,寫進 lower 頁,落在一條字線上第 4 到第 7 個單元的最低位。每個單元的另外 3 位來自 middle、upper、top 三個頁,單元的檔位由 4 位共同決定,於是這 4 個單元分別處在 L4、L8、L14、L10。 寫入之前 QLC 的一條字線(示意) 一個權重 w−0.0126 縮放 s0.0042 w/s + 85 4 位碼0101 控制器 加擾0101 ⊕ 0110 = 0011 校驗另附 ECC 位 寫到lower 頁 加擾序列和頁的分配都由盤決定 單元 0 1 2 3 4 5 6 7 lower 頁 1011 0011 middle 頁 01101001 upper 頁 11001101 top 頁 00100111 檔位 L6L4L13L1 L4L8L14L10 閾值電壓 L0 L15 16 個視窗,一個單元落在其中一個 這個權重的 4 位只佔 4 個單元各自的最低位; 每個單元的檔位還取決於另外 3 頁裡不相干的資料。
圖 2 · 按數量算,一個 4 位權重對應一個 QLC 單元;但寫進盤以後,它的 4 位分散在 4 個單元裡,每個單元的電荷量混著 4 頁的資料。檔位編碼按格雷碼示意,實際排列由廠商決定。

所以,按數量算,這塊盤裝得下 30B 個“突觸”,每個單元的精度也和突觸差不多;只是值和物理量之間的對應關係,被控制器有意打亂了。那麼,盤裡存著這些數,算不算像神經元那樣“記住”了它們?


二、兩種記憶:按地址讀取與按內容回憶

盤的記憶:給出地址,取回一塊

從盤裡取東西,唯一的辦法是給出地址。如果你只記得內容的一部分,比如“那條記憶大概是 1011 0010 開頭的”,盤幫不上忙,只能把整塊盤讀出來,由 CPU 一條條去比。比較這件事發生在 CPU 裡,不在盤裡。

盤上的儲存單元還被刻意設計成互不影響。機械硬碟的磁性顆粒之間隔著非磁性的晶界,免得一個顆粒的磁化方向帶動鄰居;快閃記憶體裡,相鄰單元之間的電容耦合被當成一種錯誤來源,控制器要花力氣去補償它3。互不影響帶來了區域性性:一個扇區的資料只在那一個地方,壞了就是壞了。ECC 糾不回來時,盤返回的是整個扇區的讀錯誤,不會給你“大致對的”資料。

神經元的記憶:給出一部分,回憶出全部

神經網路裡最經典的記憶模型是 1982 年的 Hopfield 網路5。它有 N 個神經元,每個取值 ±1,任意兩個神經元之間有一個連線權重 WijW_{ij}。要存 P 條記憶 ξ1,…,ξP\xi^1, \dots, \xi^P,用 Hebb 規則(一起啟用的神經元,連線就加強)把它們疊加到同一個權重矩陣裡:

W=1N∑μ=1Pξμ(ξμ)⊤,Wii=0W = \frac{1}{N}\sum_{\mu=1}^{P} \xi^{\mu} \left(\xi^{\mu}\right)^{\top}, \qquad W_{ii} = 0

回憶時,從一條線索 ss 出發,反覆做 s←sign⁡(Ws)s \leftarrow \operatorname{sign}(W s),直到狀態不再變化。只要存的條數不超過約 0.138N,每條記憶都是一個穩定的吸引子6:線索落在它附近,就會被拉回到它本身。

這裡有兩點和盤完全不同。第一,每條記憶都攤在全部 N² 個權重上,每個權重也都承載著所有記憶的一小部分,沒有“第 17 條記憶存在哪”這回事。第二,取回記憶靠的不是地址,而是內容:給出一個有錯、不全的版本,網路自己演化到最近的那條。

按地址讀取與按內容回憶 左邊是扇區方式:50 條記憶各佔一個扇區,地址是內容的 SHA-256;第 17 條記憶錯了 1 位,雜湊就從 bd86…a3 變成 3438…f6,查不到。右邊是 Hopfield 網路:第 17 條記憶錯了 30%,與原記憶重合 70.0%,經過 s ← sign(Ws) 一輪變成 96.5%,兩輪變成 100%。 硬碟:給地址,取回一塊 Hopfield:給一部分,回憶出全部 沒有這個地址 s ← sign(W s) s ← sign(W s) 扇區 地址 = SHA-256(內容) e6bf…64#161001 0000 … bd86…a3#170001 1001 … 47ed…9e#181101 1101 … … 共 50 個扇區 線索:#17 錯了 1 位 內容0001 1001 … (第 k 位翻轉) SHA-2563438…f6 線索:#17 錯了 30% 與 #17 重合 70.0% 第 1 輪 96.5% 第 2 輪:#17 100% 50 條記憶都疊在同一個 1024×1024 的 W 裡, 沒有“第 17 條存在哪”這回事。 數字取自文中實驗的第 17 條記憶
圖 3 · 盤只認完整的地址,錯 1 位的線索換來一個完全不同的雜湊;Hopfield 網路從錯了 30% 的線索出發,兩輪就回到原來的記憶。

實驗:同樣 50 條記憶,兩種存法

光說不夠直觀,我們做一個小實驗。隨機生成 50 條記憶,每條 1024 位,分別用兩種方式存:

  • 扇區方式:每條記憶佔一個扇區,用內容的 SHA-256 當地址。這是在按地址儲存上做“按內容找”最直接的辦法。
  • Hopfield 方式:N = 1024 個神經元,50 條記憶用 Hebb 規則疊進一個 1024×1024 的權重矩陣,負載 50/1024 ≈ 0.049,遠低於容量上限。

然後測兩件事:線索有錯時能不能取回,以及介質壞掉一部分以後還能取回幾條。介質損壞在扇區方式裡是隨機壞掉一部分扇區,在 Hopfield 方式裡是隨機剪斷一部分連線(把權重置零)。

50 條 1024 位的記憶,兩種存法
條件扇區:完整取回Hopfield:完整取回Hopfield:平均每條對的位數
線索有錯,介質完好
錯 0%50 / 5050 / 50100%
錯 1%0 / 5050 / 50100%
錯 10%0 / 5050 / 50100%
錯 30%0 / 5050 / 50100%
錯 40%0 / 5046 / 5098.13%
介質壞掉一部分(Hopfield 的線索另有 10% 的錯)
壞 10%45 / 5049 / 50> 99.99%
壞 30%35 / 5043 / 5099.99%
壞 50%25 / 5027 / 5099.91%
壞 70%15 / 500 / 5099.10%
壞 90%5 / 500 / 5085.46%

扇區方式裡,壞掉的扇區整塊讀不出來,沒壞的完整無誤,所以沒有“對了多少位”這一列。Hopfield 方式裡的“壞”是隨機剪斷這一比例的連線。指令碼見文末,隨機種子固定,結果可復現。

表 1 · 按地址存,線索必須一位不差,壞掉的記憶整條消失;按 Hopfield 存,錯 30% 的線索也能回憶,連線剪掉 70% 時每條記憶仍有 99% 的位是對的

表 1 說明了三件事。

按內容取,盤只認完全一樣的線索。 錯 1 位,雜湊就完全不同,50 條一條也找不回來;Hopfield 網路線上索錯了 30% 時仍然全部回憶正確。

壞的方式不一樣。 扇區壞掉一半,就有一半記憶整條消失,剩下的一半完好無損;Hopfield 的連線剪掉 70%,沒有一條記憶還能一位不差,但每條平均仍有 99.1% 的位是對的。前者是“要麼全有、要麼全無”,後者是所有記憶一起慢慢變模糊。

神經元式的記憶很貴。 扇區方式用 51,200 位存了 51,200 位;Hopfield 用了 1,048,576 個權重(每個還不止 1 位),是前者的 20 倍以上。每回憶一次,還要做好幾次 1024×1024 的矩陣乘向量。

差別在“讀”的方式,不在儲存單元

把這個實驗拆開看:Hopfield 網路的“記憶”,是權重矩陣 WW 加上更新規則 s←sign⁡(Ws)s \leftarrow \operatorname{sign}(W s) 兩部分合起來才有的。只有 WW,它就是一百萬個數;把 WW 寫進盤,盤有了 WW,卻沒有那個規則。

大模型也是這樣。有研究發現,Transformer 的前饋層就像一組鍵值記憶:隱藏向量和每個“鍵”做內積,衡量當前輸入和某種文字模式有多匹配,再按匹配程度把對應的“值”加權求和7。注意力的更新規則,也已經被證明和現代 Hopfield 網路的更新等價8。在這些模型裡,“按內容回憶”都是靠矩陣乘法完成的。

所以,對第二個問題的回答是:盤有了突觸,但沒有神經元。 寫進盤的 30B 個引數,要變成記憶,必須有什麼東西拿著它們去做矩陣乘法。最直接的分工,就是盤只負責存,CPU 或 GPU 負責算。那麼,每生成一個 token,要從盤裡搬多少資料?


三、盤只儲存、處理器計算:每個 token 的讀盤量

稠密模型:每個 token 都要把權重讀一遍

大模型生成文字是一個 token 一個 token 往外吐的。每生成一個 token,每個權重都要參與一次乘加。只服務一個使用者時,從儲存裡讀出的每個位元組只換來一兩次運算,速度幾乎完全由讀權重的頻寬決定。

如果是一個 30B 的稠密模型,4 位量化後約 15.3 GB,那麼每生成一個 token 就要把這 15.3 GB 讀一遍。

MoE:一個 token 只用到一小部分專家

Qwen3-30B-A3B 是 MoE(混合專家)模型:每一層有一個路由器,根據當前 token 的隱藏向量,從 128 個專家裡挑 8 個來算1。專家引數一共 28,991,029,248 個,佔全部引數的 95%;每個 token 只用到其中的 48 × 8 = 384 個專家,按 4 位算是 0.91 GB。剩下的 1.54B 個非專家引數(注意力、詞嵌入、路由器)4 位後約 0.77 GB,每個 token 都要用,常駐記憶體。

生成一個 token 要從盤上讀哪些專家 48 行代表 48 層,每行 128 格代表 128 個專家,每格 2.36 MB,按層號和專家號依次存放在裸盤上。生成一個 token 時每層只亮 8 格,共 384 格,0.91 GB,而全部專家有 6,144 格,14.5 GB。 Qwen3-30B-A3B 的專家在裸盤上的排布 專家 0 · LBA 0 專家 127 第 0 層 第 12 層 第 24 層 第 36 層 第 47 層 這個 token 讀 384 塊 × 2.36 MB = 0.91 GB 全部專家 6,144 塊 = 14.5 GB 地址從左上角開始,先走完一行(一層的 128 個專家,302 MB),再換到下一行。 亮的格子是路由器為當前 token 選中的專家,每層 8 個;位置為示意。
圖 4 · 一個 token 只用到 6,144 個專家裡的 384 個。它們散落在盤上的 384 個位置,每個位置連續讀 2.36 MB。

這和神經元的工作方式有一點像:大腦裡的神經元在任一時刻也只有一小部分在放電。

算賬:不同的盤,每個 token 要等多久

只看讀盤時間,不算計算,也不考慮快取,結果如表 2。

生成一個 token,光讀權重要多久
儲存讀頻寬稠密 30B(讀 15.3 GB)Qwen3-30B-A3B(讀 0.91 GB)
記憶體:DDR5-5600 雙通道89.6 GB/s0.17 s0.010 s
NVMe:三星 990 PRO7,450 MB/s2.0 s0.12 s
SATA 固態盤約 550 MB/s28 s1.7 s
本文的雲盤(實測)163 MB/s94 s5.6 s
7200 轉機械硬碟約 250 MB/s61 s8.3 s

只算讀權重的時間,不算計算,不考慮快取;MoE 一列不含常駐記憶體的 0.77 GB 非專家引數。記憶體和三種盤按標稱或典型頻寬估算,機械硬碟每次隨機讀另加約 12 ms 的尋道和旋轉等待;雲盤一行是實測。

表 2 · 同樣是 30B,MoE 每個 token 只讀十七分之一的資料。NVMe 上每秒能出約 8 個 token,機械硬碟每個 token 要等 8 秒以上

機械硬碟那一行要多解釋一句。它的順序讀能到 250 MB/s 左右,但每次隨機讀都要先移動磁頭、再等碟片轉到位置:7200 轉的盤轉一圈 8.33 ms,平均要等半圈 4.17 ms,再加上平均約 8 ms 的尋道,每次隨機讀要多花約 12 ms。MoE 每個 token 要做 384 次這樣的隨機讀,光等磁頭就要 4.7 秒。

雲盤那一行是實測的:我寫這篇文章用的是一臺 4 核的雲主機,系統盤是一塊 50 GB 的雲盤(lsblk 顯示型號為 PersistentDisk)。用文末的指令碼按上面的佈局寫了 8 層專家(2.42 GB),用 O_DIRECT 繞過頁快取讀回來,順序讀和按 MoE 模式隨機讀都是 160 MB/s 左右,折算到 48 層每個 token 要 5.6 秒。這塊盤被限速了,2.36 MB 一次的讀也足夠大,所以隨機讀沒有比順序讀慢。

讓常用的專家留在記憶體裡

上面的演算法有一個明顯的浪費:相鄰的幾個 token 往往會用到大量相同的神經元和專家,每次都從盤上重新讀,等於把同樣的資料搬了很多遍。

蘋果的 LLM in a flash 就是從這裡入手的9。它把最近幾個 token 啟用過的神經元留在記憶體裡(視窗化),每個新 token 只從快閃記憶體讀新增的那部分;再把一起被用到的行和列存在相鄰位置,讓每次讀都儘量大、儘量連續(行列捆綁)。這樣能跑比記憶體大一倍的模型,比樸素的按需載入在 CPU 上快 4–5 倍,在 GPU 上快 20–25 倍。PowerInfer-2 用類似的思路,按神經元簇來排程計算和 I/O,在手機上跑起了 47B 的模型,11.68 token/s10。

到這裡,第三個問題有了答案:用 NVMe 固態盤配 MoE 模型,把 30B 引數平鋪在裸盤上、邊讀邊算,是可以跑起來的,每秒幾個 token;機械硬碟每個 token 要等好幾秒,不實用。 但是在這種分工裡,盤只是一塊慢一點的記憶體,“回憶”這件事仍然發生在處理器裡。能不能不把資料搬出來,讓引數在盤裡就地參與計算?


四、讓儲存單元參與計算

浮柵單元本來就能做乘法

一個浮柵電晶體存的電荷,決定了它在給定電壓下能導通多大的電流,可以把它看成一個可調的電導 GG。在它兩端加一個電壓 VV,流過的電流就是 I=G⋅VI = G \cdot V,一次乘法就完成了。把一列單元並聯在同一根位線上,各自的電流在位線上自然相加(基爾霍夫電流定律),於是這根位線上的總電流就是一個內積 ∑iGiVi\sum_i G_i V_i。整個陣列一次讀出,就完成了一次矩陣乘向量。

這樣的實驗早就有人做過。2016 年,Strukov 和 Likharev 等人把商用 180 nm NOR 快閃記憶體改造成模擬計算陣列,用 101,780 個浮柵單元當突觸,每個單元的電導可以調到約 1% 的精度。在 MNIST 手寫數字識別上,晶片做到了 94.65% 的準確率(模擬為 96.2%),分類一張圖不到 1 微秒,耗能約 20 納焦11。在這裡,一個權重的值就是一個單元的狀態,圖 2 裡被控制器打亂的那種對應關係又回來了。

NOR 陣列和 NAND 串 左邊是 NOR 陣列:三個輸入電壓 0.2、0.5、0.1 伏加在三行上,每個單元的電導是一個權重,同一根位線上的電流相加,位線 1 的電流是 4×0.2 + 1×0.5 + 7×0.1 = 2.0 微安,一次讀出就是一次內積。右邊是 NAND 串:六個單元串聯在位線和源極之間,讀第 3 條字線時,其餘字線加導通電壓,電流只由被讀的單元決定,不能相加。 NOR 陣列:單元並聯,電流在位線上相加 NAND 串:單元串聯 位線 1 位線 2 V₁ = 0.2 V V₂ = 0.5 V V₃ = 0.1 V G = 4 G = 1 G = 7 G = 2 G = 6 G = 3 I₁ = 2.0 μA I₂ = 3.7 μA I₁ = 4×0.2 + 1×0.5 + 7×0.1 = 2.0 μA 電導 G 的單位是 μS;數值為示意 位線 WL0 · V_pass WL1 · V_pass WL2 · V_pass WL3 · V_read(被讀) WL4 · V_pass WL5 · V_pass 源極 其餘單元加導通電壓,電流只看被讀的那個; 同時讀幾條字線,全都導通才有電流,等於“與”。
圖 5 · NOR 陣列裡,歐姆定律做乘法、基爾霍夫電流定律做加法,一次讀出就是一次矩陣乘向量;SSD 裡的 NAND 把單元串起來換密度,電流不能相加,只能做按位運算。

SSD 裡的 NAND:串聯結構只適合按位運算

問題在於,SSD 用的不是 NOR,而是 NAND。NAND 為了密度,把幾十到上百個單元串聯成一串,共用一根位線。讀其中一個單元時,要給串上其他所有單元加一個足夠高的導通電壓,讓它們全部導通,只留被讀的那個決定電流。串聯的單元電流不會相加,只會被最弱的那個卡住。

串聯也不是全無用處。Flash-Cosmos 發現,同時感應一串裡的多條字線,只有每個單元都導通時才有電流,相當於對這些位做“與”;同時感應掛在同一根位線上的多個塊,任何一串導通就有電流,相當於做“或”。作者在 160 顆真實的 3D NAND 晶片上驗證了這種做法12。但這只是按位運算,不是乘加。

要在快閃記憶體裡跑大模型,就得改晶片。Cambricon-LLM 設計了一顆專門的 NAND 快閃記憶體晶片,在片內加入計算單元和 ECC,讓快閃記憶體負責輕量的片上運算,NPU 負責其餘的矩陣運算和特殊函式。在它的評估裡,70B 模型能跑到 3.44 token/s,7B 模型 36.34 token/s,比從快閃記憶體解除安裝權重的方案快 22–45 倍13。

這些都是專門設計的晶片。買來的 SSD 只透過 NVMe 或 SATA 介面收發資料塊,主機沒有辦法讓它的快閃記憶體去做乘加。機械硬碟更不行:磁頭一次只能沿一條磁軌序列地讀,介質本身沒有可以利用的並行物理過程。機械硬碟這條路,到這裡就走到頭了。

模擬計算還有它自己的代價:單元的電導會隨溫度漂移,每根位線都要配一個模數轉換器,1% 的精度大約只相當於 6–7 位。4 位量化的大模型能容忍一定的噪聲,但要在幾十層裡層層累積,誤差能不能控制住,仍是這類晶片要解決的問題。

單元能算了,下一步自然想問:它能不能像突觸一樣,邊用邊學?


五、在盤上學習:寫入的代價

突觸可以雙向調整,快閃記憶體單元只能單向寫

突觸的強度可以增強(長時程增強,LTP),也可以減弱(長時程抑制,LTD),調整隻發生在這一個突觸上,不影響旁邊的。

快閃記憶體單元做不到。程式設計(寫)是往浮柵裡注入電子,只能讓閾值電壓升高,而且以頁為單位進行;要讓閾值電壓降回來,只能把整個塊擦除,一個塊裡有成百上千個頁3。梯度下降的每一步,都要讓每個權重或增或減,落到快閃記憶體上,就只能把新值寫到新的頁裡,舊頁標記作廢,等以後整塊搬走、擦除。

突觸和快閃記憶體單元怎樣改一個值 突觸的強度可以就地增強或減弱,隻影響這一個連線。快閃記憶體單超程式設計只能抬高閾值電壓,要把一個值改小,只能寫到新頁、舊頁作廢,等整塊擦除。按每步重寫 366 GB 計算,一塊 1,200 TBW 的盤只夠訓練約 3,300 步。 突觸:就地增強,也能就地減弱 快閃記憶體單元:寫只能加,減要整塊擦 壽命算賬:用 Adam 訓練 30B,狀態放在 990 PRO 2 TB 上 一個突觸 當前強度0.42 增強 LTP0.42 → 0.47 減弱 LTD0.42 → 0.38,就地完成 影響範圍只有這一個連線 一個 NAND 單元 程式設計(寫)按頁,只能抬高閾值電壓 改小一個值寫到新頁,舊頁作廢 擦除整塊,成百上千頁一起 代價每次擦寫消耗一次壽命 每步重寫30.5B × 12 B = 366 GB 標稱寫入壽命1,200 TBW 夠訓練1,200 TB ÷ 366 GB ≈ 3,300 步 12 B = FP32 主權重 + 兩份動量。 預訓練動輒幾十萬步。
圖 6 · 梯度下降每一步都要讓權重有增有減;突觸能就地減弱,快閃記憶體單元只能把新值寫到別處,再整塊擦掉舊的,壽命經不起訓練的消耗。突觸的數值為示意。

壽命算賬

這不只是理論上的彆扭。ZeRO-Infinity 確實把訓練時的引數和最佳化器狀態放到 NVMe 上,以此在有限的 GPU 上訓練超大模型14。但如果 30B 模型用 Adam 訓練,FP32 主權重和兩份動量每個引數 12 位元組,每一步都要重寫 366 GB。三星 990 PRO 2 TB 款的標稱寫入壽命是 1,200 TBW15,夠寫約 3,300 步。預訓練一個大模型動輒幾十萬步,這塊盤撐不過開頭。

快閃記憶體適合“寫一次、讀很多次”

反過來,只讀的推理正是快閃記憶體擅長的。按 JEDEC 的規定,消費級 SSD 即使用完了標稱壽命,斷電放在 30°C 下資料也要能保持一年16;新盤的保持時間還要長得多。長期反覆讀同一塊資料,會因為讀干擾讓鄰近單元慢慢偏移,但控制器會定期把資料重新整理到新位置3。

所以對“能不能在盤上學習”的回答是:可以寫,但每次更新都是整頁搬遷,寫入壽命經不起訓練的消耗。“固化”這個詞其實很準確:在 GPU 上訓練好,把引數一次寫進盤裡,以後只讀。頂多再掛一個很小的 LoRA 介面卡,只更新這一小部分引數。

既然盤最適合“訓練完寫一次、以後只讀”,那要把 30B 固化到盤上,模型應該長成什麼樣?


六、適合固化在盤上的模型結構

前面幾節提出的要求

把前面的結論收攏一下,一個適合放在盤上的模型應該滿足四點:

  1. 按地址讀,而不是按內容搜(第二節)。內容到地址的換算由處理器來做,盤只負責“給地址、還一塊”。
  2. 每個 token 讀得少(第三節)。讀盤量決定速度。
  3. 地址要早知道(第三節)。機械硬碟每次隨機讀要等 12 ms,NVMe 也有幾十微秒的延遲,越早知道要讀什麼,越能把等待藏在計算後面。
  4. 引數訓練好以後不再改(第五節)。

MoE 滿足前兩點的一部分:每個 token 只讀 0.91 GB。但它的路由器要用當前層的隱藏向量來選專家,要讀哪些專家,直到這一層開始算之前才知道,沒有提前預取的餘地。

記憶層與 Engram:把查表做成模型的一層

另一類結構直接把“查表”做成了模型的一層。2019 年的乘積鍵記憶層(Product Key Memory)給 Transformer 加了一張最多十億引數的大表,每個 token 只按鍵取出其中幾行;加了這一層的 12 層模型,效果超過了 24 層的基線,推理還快一倍17。2024 年 Meta 把這種記憶層擴到了 128B 引數,在計算量相當時,效果超過了計算量多一倍以上的稠密模型,也超過了計算量和引數量都相當的 MoE,在事實類任務上提升尤其明顯18。

2026 年初 DeepSeek 發表的 Engram 更進一步19。它把經典的 N-gram 嵌入現代化:取當前位置前面的幾個 token 組成 N-gram,用幾個雜湊函式算出它在一張大嵌入表裡的行號,取出那幾行,再由一個門控根據當前隱藏向量決定用多少。論文把 Engram 擴到 27B 引數,在總引數量和計算量都相同的條件下超過了純 MoE 的基線。

對盤來說,Engram 最關鍵的性質是:行號只取決於輸入的 token,不取決於隱藏向量。前向計算一開始,甚至在它開始之前,就知道要讀哪些行,可以提前取。論文的實驗是把一張 100B 引數的表整個放在主機記憶體裡,透過 PCIe 預取,8B 骨幹的吞吐只降了 2.8%。論文還指出,N-gram 的出現頻率服從 Zipf 分佈,常用的少數行可以快取在視訊記憶體或記憶體裡,長尾放到 NVMe SSD 上19。

把 Engram 式的嵌入表放在裸盤上 當前位置的 2-gram“能 像”和 3-gram“硬碟 能 像”經過雜湊,分別得到嵌入表的行號 7,301,442 和 912,077。如果一行正好 4 KiB,行號就是 LBA。行號只取決於輸入的 token,第 1 層還在計算時就能向盤發出讀請求,取回的嵌入在第 2 層經過門控加進隱藏狀態。 GPU / 記憶體:骨幹網路 裸盤:嵌入表(只讀) 當前位置的 N-gram 輸入:… 硬碟 能 像 2-gram能 像雜湊 → 行 7,301,442 3-gram硬碟 能 像雜湊 → 行 912,077 合計每階 4 個雜湊頭,共 8 行 第 1 層計算中,同時預取 第 2 層 · Engram 門控 第 3 層 … 取回的嵌入 行號只取決於輸入的 token,第 1 層還在算時, 讀請求就可以發給盤了。 嵌入表 行 912,077LBA 912,077 行 7,301,442LBA 7,301,442 一行2048 維 × 16 位 = 4 KiB … 一行正好一個扇區,行號就是 LBA。 每個 token:8 行 × 4 KiB = 32 KiB。 尺寸和行號均為示意,不是論文的配置。
圖 7 · 記憶層把“按內容找”拆成兩半:處理器把 N-gram 雜湊成行號,盤按行號還回一個扇區。地址在計算開始前就已知,讀盤的等待可以藏在前幾層的計算後面。

這正好滿足了上面的四點要求:按地址讀,每個 token 只讀幾行,前向一開始就知道地址,表訓練好以後不再改。分工也隨之清楚了:留在記憶體或視訊記憶體裡的是一個較小的骨幹網路,放到盤上的是那張大表。按圖 7 的示意,每個 token 從盤上只讀幾十 KB,比 MoE 的 0.91 GB 小四個數量級。不過要說明:論文實測的是主機記憶體,長尾放在 SSD 上只是論文提出的方向;表放在裸盤上能跑多快,是本文的推斷,還沒有人測過。

有意思的是,engram 這個詞在神經科學裡,指的正是一段記憶在大腦裡留下的物理痕跡。

固化的另一端:把引數做成電路

如果把“固化”推到極致,就是連盤也不要了,直接把引數做成電路。Taalas 在 2026 年 2 月釋出的 HC1 晶片,把 Llama 3.1 8B 硬連線進了矽片,採用 3 位和 6 位混合量化,單使用者能跑到每秒 17,000 個 token;引數本身不能改,只保留了上下文長度的配置和 LoRA 微調20。在這裡,儲存和計算徹底合成了一件事,和突觸最像,代價是一個晶片只能是一個模型。

把這幾種“固化”的程度放在一起比較:

“固化”的幾種程度
方式引數在哪誰來計算速度(例)能不能改
權重檔案檔案系統裡,用前整個載入進記憶體或視訊記憶體CPU / GPU取決於記憶體頻寬隨時替換
裸盤平鋪,按需讀盤上,按偏移量定址CPU / GPU 邊讀邊算Qwen3-30B-A3B 在 NVMe 上約 8 token/s(本文估算的上限)重寫盤即可
快閃記憶體內計算專用快閃記憶體晶片的單元裡快閃記憶體片上 + NPUCambricon-LLM:70B 3.44 token/s能重新程式設計,受寫入壽命限制
硬連線晶片電路本身電路本身Taalas HC1:Llama 3.1 8B 17K token/s不能改,只能掛 LoRA
表 3 · 引數和計算靠得越近,速度越快,能改的餘地也越小

七、回到那塊寫滿權重的盤

現在可以回答開頭的問題了。那塊 dd 過的盤上,確實存著 30B 個“突觸”:每個 QLC 單元的精度和一個突觸差不多,斷電一年也不會丟。但它記住這些數的方式,是圖書館的方式,不是大腦的方式:

  • 它只能按地址取,不能按內容回憶;錯一位的線索,什麼也找不回來。
  • 壞掉的扇區整塊丟失,不會“大致記得”。
  • 它不會自己用這些數做任何計算,“回憶”要靠處理器完成。

要讓這塊盤真正派上用場,有三條路:

  • NVMe 加 MoE,處理器邊讀邊算,Qwen3-30B-A3B 每秒能出幾個 token。今天就能做,llama.cpp 用 mmap 載入模型,其實就是讓作業系統替你做這件事,只不過中間隔著檔案系統。
  • 在快閃記憶體晶片裡計算,讓單元的電荷直接參與乘加。這已經接近一個突觸陣列,但要專門的晶片,不是買來的 SSD。
  • 換一種模型結構,像 Engram 那樣把知識放進一張按 token 定址的大表,讓盤只做它最擅長的事:給地址,還一塊。

至於在盤上學習,快閃記憶體單向寫、整塊擦的特性和有限的寫入壽命,決定了它只適合訓練好以後寫一次。“固化”這個詞,恰好描述了盤能做的事。


小結

從一塊寫滿權重的裸盤出發,我們一路追問到了:

  1. 裸盤上的引數是什麼形態? 一個按偏移量定址的大陣列,適合按層、按專家平鋪。往下一層,一個 QLC 單元約存 4 位,和一個突觸約 4.7 位元的精度很接近,但控制器的加擾和頁編碼把“一個值對應一個單元”打亂了。
  2. 盤算不算“記住”了? 它有突觸,沒有神經元。按地址讀取,錯一位就找不回來,壞一塊就丟一塊;Hopfield 網路按內容回憶,線索錯 30% 仍能想起,代價是 20 倍以上的儲存和每次回憶都要做矩陣乘法。
  3. 盤只儲存、處理器計算,30B 能跑多快? 稠密模型每個 token 要讀 15.3 GB,NVMe 上要 2 秒;MoE 只讀 0.91 GB,NVMe 上每秒約 8 個 token 的上限,機械硬碟每個 token 要 8 秒以上。
  4. 儲存單元能不能就地計算、就地學習? NOR 快閃記憶體可以靠歐姆定律和基爾霍夫定律做模擬乘加,SSD 裡串聯的 NAND 只適合按位運算,要算大模型就得用專門的晶片。快閃記憶體只能單向寫、整塊擦,寫入壽命經不起訓練,只適合寫一次。
  5. 怎樣固化 30B 最合適? 選按地址查表、地址只取決於輸入的結構,比如記憶層和 Engram;放在 NVMe 上,熱的行留在記憶體裡。

如果想自己驗證,下面是文中用到的兩個指令碼,只依賴 NumPy。

第一個是第二節的實驗,比較按扇區存和用 Hopfield 網路存(4 核機器上約 8 秒):

Python
"""同样 50 条 1024 位的记忆,分别按“扇区”和按 Hopfield 网络存,比较两件事:
1. 拿一条有噪声的线索去取,能不能取回原来那条;
2. 存储介质坏掉一部分以后,还能取回几条。
"""
import hashlib
import numpy as np
N, P = 1024, 50 # 每条记忆 1024 位,共 50 条
rng = np.random.default_rng(0)
patterns = rng.choice([-1, 1], size=(P, N)).astype(np.int8)
def flip(x, frac, rng):
"""随机翻转 frac 比例的位,模拟一条不完整、有错的线索。"""
y = x.copy()
idx = rng.choice(N, size=int(frac * N), replace=False)
y[idx] *= -1
return y
# ---------- 方式一:按地址存(扇区) ----------
# 用内容的哈希当地址:这是“按内容找”在按地址存储上最直接的做法。
def addr(x):
return hashlib.sha256(x.tobytes()).hexdigest()
disk = {addr(p): p for p in patterns}
sector_of = {addr(p): i for i, p in enumerate(patterns)} # 每条记忆占一个扇区
def disk_recall(cue, dead=frozenset()):
a = addr(cue)
if a not in disk or sector_of[a] in dead:
return None
return disk[a]
# ---------- 方式二:Hopfield 网络 ----------
W = (patterns.T.astype(np.float32) @ patterns.astype(np.float32)) / N # Hebb 规则
np.fill_diagonal(W, 0)
def hopfield_recall(W, cue, steps=20):
s = cue.astype(np.float32)
for _ in range(steps): # 同步更新,直到不再变化
s_new = np.where(W @ s >= 0, 1.0, -1.0)
if np.array_equal(s_new, s):
break
s = s_new
return s.astype(np.int8)
def exact(out, p):
return out is not None and np.array_equal(out, p)
print(f"N={N} 位/条, P={P} 条")
print(f"扇区方式占用: {P * N} 位; Hopfield 权重: {N * N} 个")
print()
print("实验一:线索有噪声(不坏介质)")
print("噪声比例 扇区:完整取回 Hopfield:完整取回 Hopfield:平均每条对的位数")
for noise in [0.0, 0.01, 0.05, 0.10, 0.20, 0.30, 0.40]:
r = np.random.default_rng(1)
cues = [flip(p, noise, r) for p in patterns]
d = sum(exact(disk_recall(c), p) for c, p in zip(cues, patterns))
outs = [hopfield_recall(W, c) for c in cues]
h = sum(exact(o, p) for o, p in zip(outs, patterns))
acc = np.mean([np.mean(o == p) for o, p in zip(outs, patterns)])
print(f"{noise:>6.0%} {d:>4}/{P} {h:>4}/{P} {acc:.2%}")
print()
print("实验二:介质坏掉一部分(扇区用干净线索;Hopfield 用 10% 噪声的线索)")
print("损坏比例 扇区:完整取回 Hopfield:完整取回 Hopfield:平均每条对的位数")
for dmg in [0.0, 0.10, 0.30, 0.50, 0.70, 0.80, 0.90]:
r = np.random.default_rng(2)
# 扇区:坏掉的扇区整块读不出来(ECC 纠不回来时,盘返回的是读错误)
dead = frozenset(r.choice(P, size=int(dmg * P), replace=False).tolist())
d = sum(exact(disk_recall(p, dead), p) for p in patterns)
# Hopfield:随机剪断 dmg 比例的“突触”(权重置零,保持对称)
mask = r.random((N, N)) >= dmg
mask = np.triu(mask, 1); mask = mask | mask.T
Wd = W * mask
cues = [flip(p, 0.10, r) for p in patterns]
outs = [hopfield_recall(Wd, c) for c in cues]
h = sum(exact(o, p) for o, p in zip(outs, patterns))
acc = np.mean([np.mean(o == p) for o, p in zip(outs, patterns)])
print(f"{dmg:>6.0%} {d:>4}/{P} {h:>4}/{P} {acc:.2%}")

第二個是第三節的讀盤實驗。先 write 把 8 層專家按文中的佈局寫進去,再 read 測順序讀和 MoE 模式的讀,並折算到 48 層。目標可以是一個普通檔案,也可以是一塊空盤的裸裝置(會覆蓋上面的資料):

Python
"""把一个 MoE 模型的专家权重平铺到裸盘(或一个大文件)上,再按“生成一个 token”的访问模式读回来,
测每个 token 要在 I/O 上花多少时间。
布局照 Qwen3-30B-A3B:每层 128 个专家,每个专家 3 个 768×2048 的矩阵,
4 位量化后正好 2,359,296 字节 = 576 个 4 KiB 扇区。专家 (layer, e) 放在
offset = (layer * 128 + e) * 2,359,296
没有文件系统,地址就是偏移量。
用法:
python3 disk_stream.py write /path/to/target --layers 8
python3 disk_stream.py read /path/to/target --layers 8 --tokens 20
target 可以是 /dev/nvme1n1 这样的裸设备(会覆盖上面的数据,需要 --i-know-this-erases),
也可以是普通文件。读写都用 O_DIRECT,绕过页缓存,测的是盘本身。
"""
import argparse, mmap, os, sys, time
import numpy as np
EXPERTS, TOPK, FULL_LAYERS = 128, 8, 48
EXPERT_BYTES = 3 * 768 * 2048 // 2 # 4 位量化:两个参数一个字节
assert EXPERT_BYTES % 4096 == 0
def offset(layer, e):
return (layer * EXPERTS + e) * EXPERT_BYTES
def open_direct(path, write):
flags = (os.O_RDWR | os.O_CREAT) if write else os.O_RDONLY
return os.open(path, flags | os.O_DIRECT, 0o644)
def cmd_write(a):
if a.target.startswith("/dev/") and not a.i_know_this_erases:
sys.exit("写裸设备会覆盖上面的数据,确认后加 --i-know-this-erases")
fd = open_direct(a.target, True)
buf = mmap.mmap(-1, EXPERT_BYTES) # mmap 出来的内存按页对齐,O_DIRECT 需要
rng = np.random.default_rng(0)
t0 = time.perf_counter()
for layer in range(a.layers):
for e in range(EXPERTS):
buf[:] = rng.integers(0, 256, EXPERT_BYTES, dtype=np.uint8).tobytes()
os.pwritev(fd, [buf], offset(layer, e))
os.fsync(fd)
dt = time.perf_counter() - t0
total = a.layers * EXPERTS * EXPERT_BYTES
print(f"写入 {total / 1e9:.2f} GB,用时 {dt:.1f} s,{total / dt / 1e6:.0f} MB/s")
def cmd_read(a):
fd = open_direct(a.target, False)
buf = mmap.mmap(-1, EXPERT_BYTES)
rng = np.random.default_rng(1)
# 1) 顺序读:稠密模型每个 token 要把全部权重扫一遍,就是这种模式
total = a.layers * EXPERTS * EXPERT_BYTES
t0 = time.perf_counter()
for i in range(a.layers * EXPERTS):
os.preadv(fd, [buf], i * EXPERT_BYTES)
seq = total / (time.perf_counter() - t0)
print(f"顺序读:{seq / 1e6:.0f} MB/s")
# 2) MoE 模式:每层随机挑 8 个专家,每个专家是一次 2.36 MB 的读
lat = []
for _ in range(a.tokens):
t0 = time.perf_counter()
for layer in range(a.layers):
for e in rng.choice(EXPERTS, TOPK, replace=False):
os.preadv(fd, [buf], offset(layer, int(e)))
lat.append(time.perf_counter() - t0)
per_layer = np.median(lat) / a.layers
moe_bytes = a.layers * TOPK * EXPERT_BYTES * a.tokens
print(f"MoE 读:{moe_bytes / sum(lat) / 1e6:.0f} MB/s,每层 {per_layer * 1e3:.1f} ms")
print(f"折算到 {FULL_LAYERS} 层:每个 token 读 {FULL_LAYERS * TOPK * EXPERT_BYTES / 1e9:.2f} GB,"
f"I/O 约 {per_layer * FULL_LAYERS:.2f} s,上限 {1 / (per_layer * FULL_LAYERS):.2f} token/s")
dense = 30.5e9 / 2
print(f"对照:稠密 30B(4 位,{dense / 1e9:.1f} GB)按顺序读速度,每个 token {dense / seq:.1f} s")
p = argparse.ArgumentParser()
p.add_argument("cmd", choices=["write", "read"])
p.add_argument("target")
p.add_argument("--layers", type=int, default=8)
p.add_argument("--tokens", type=int, default=20)
p.add_argument("--i-know-this-erases", action="store_true")
a = p.parse_args()
cmd_write(a) if a.cmd == "write" else cmd_read(a)

參考資料

參考資料

  1. Qwen3-30B-A3B config.jsonHugging Facehuggingface.co ↗48 層,每層 128 個專家,每個 token 選 8 個,專家中間維度 768,隱藏維度 2048。模型頁給出的總引數量是 30,532,122,624(BF16)。https://huggingface.co/Qwen/Qwen3-30B-A3B/blob/main/config.json ↩ ↩2 ↩3

  2. safetensorsGitHub · Hugging Facegithub.com ↗檔案格式:8 位元組的頭長度,一段 JSON 頭(每個張量的 dtype、shape、data_offsets),後面是連續的原始位元組。https://github.com/huggingface/safetensors ↩

  3. Error Characterization, Mitigation, and Recovery in Flash Memory Based Solid-State DrivesYu Cai, Saugata Ghose, Erich F. Haratsch, Yixin Luo, Onur Mutlu · Proceedings of the IEEE 105 · 2017arxiv.org ↗多級單元的頁編碼、單元間干擾、讀干擾、資料加擾、按頁程式設計按塊擦除等,都可以在這篇綜述裡找到。https://arxiv.org/abs/1706.08642 ↩ ↩2 ↩3 ↩4 ↩5

  4. Nanoconnectomic upper bound on the variability of synaptic plasticityThomas M Bartol Jr 等 · eLife 4:e10778 · 2015elifesciences.org ↗大鼠海馬突觸大約能區分出 26 檔強度,約合 4.7 位元。具體數字憑領域知識整理,發文前可再核對原文。https://elifesciences.org/articles/10778 ↩

  5. Neural networks and physical systems with emergent collective computational abilitiesJ. J. Hopfield · PNAS 79(8) · 1982doi.org ↗https://doi.org/10.1073/pnas.79.8.2554 ↩

  6. Storing infinite numbers of patterns in a spin-glass model of neural networksDaniel J. Amit, Hanoch Gutfreund, H. Sompolinsky · Physical Review Letters 55 · 1985doi.org ↗Hopfield 網路的容量約為 0.138N。憑領域知識整理,發文前可再核對。https://doi.org/10.1103/PhysRevLett.55.1530 ↩

  7. Transformer Feed-Forward Layers Are Key-Value MemoriesMor Geva, Roei Schuster, Jonathan Berant, Omer Levy · EMNLP 2021arxiv.org ↗https://arxiv.org/abs/2012.14913 ↩

  8. Hopfield Networks is All You NeedHubert Ramsauer 等 · ICLR 2021arxiv.org ↗連續狀態的現代 Hopfield 網路,其更新規則與 Transformer 的注意力等價。https://arxiv.org/abs/2008.02217 ↩

  9. LLM in a flash: Efficient Large Language Model Inference with Limited MemoryKeivan Alizadeh 等 · ACL 2024arxiv.org ↗視窗化(windowing)和行列捆綁(row-column bundling),能跑比 DRAM 大一倍的模型,比樸素載入在 CPU 上快 4–5 倍、GPU 上快 20–25 倍。https://arxiv.org/abs/2312.11514 ↩

  10. PowerInfer-2: Fast Large Language Model Inference on a SmartphoneZhenliang Xue 等 · arXiv · 2024arxiv.org ↗在手機上跑 47B 模型,11.68 token/s。https://arxiv.org/abs/2406.06282 ↩

  11. Sub-1-us, Sub-20-nJ Pattern Classification in a Mixed-Signal Circuit Based on Embedded 180-nm Floating-Gate Memory Cell ArraysF. Merrikh Bayat, X. Guo, M. Klachko, M. Prezioso, K. K. Likharev, D. B. Strukov · arXiv · 2016arxiv.org ↗由商用 180 nm NOR 快閃記憶體改造的浮柵陣列,101,780 個浮柵單元當突觸,調節精度約 1%,MNIST 94.65%。https://arxiv.org/abs/1610.02091 ↩

  12. Flash-Cosmos: In-Flash Bulk Bitwise Operations Using Inherent Computation Capability of NAND Flash MemoryJisung Park 等 · MICRO 2022arxiv.org ↗多字線同時感應(Multi-Wordline Sensing),在 160 顆真實 3D NAND 晶片上驗證。https://arxiv.org/abs/2209.05566 ↩

  13. Cambricon-LLM: A Chiplet-Based Hybrid Architecture for On-Device Inference of 70B LLMZhongkai Yu 等 · MICRO 2024arxiv.org ↗專用 NAND 快閃記憶體晶片做快閃記憶體內計算,配合 NPU:70B 模型 3.44 token/s,7B 模型 36.34 token/s。https://arxiv.org/abs/2409.15654 ↩

  14. ZeRO-Infinity: Breaking the GPU Memory Wall for Extreme Scale Deep LearningSamyam Rajbhandari 等 · SC 2021arxiv.org ↗訓練時把引數和最佳化器狀態解除安裝到 CPU 記憶體和 NVMe 上。https://arxiv.org/abs/2104.07857 ↩

  15. Samsung NVMe SSD 990 PRO Data SheetSamsung Semiconductordownload.semiconductor.samsung.com ↗順序讀 7,450 MB/s;寫入壽命 1 TB 款 600 TBW、2 TB 款 1,200 TBW,按 JESD218 測試。https://download.semiconductor.samsung.com/resources/data-sheet/Samsung_NVMe_SSD_990_PRO_Datasheet_Rev.1.0.pdf ↩

  16. JESD218: Solid-State Drive (SSD) Requirements and Endurance Test MethodJEDECjedec.org ↗消費級 SSD 在用完標稱寫入壽命後,斷電 30°C 下資料保持 1 年。該頁面需要登入,數字憑領域知識整理,發文前可再核對。https://www.jedec.org/standards-documents/docs/jesd218b01 ↩

  17. Large Memory Layers with Product KeysGuillaume Lample 等 · NeurIPS 2019arxiv.org ↗https://arxiv.org/abs/1907.05242 ↩

  18. Memory Layers at ScaleVincent-Pierre Berges 等 · arXiv · 2024arxiv.org ↗https://arxiv.org/abs/2412.09764 ↩

  19. Conditional Memory via Scalable Lookup: A New Axis of Sparsity for Large Language ModelsXin Cheng 等(DeepSeek) · arXiv · 2026arxiv.org ↗Engram:用雜湊過的 N-gram 查嵌入表。推理時把 100B 引數的表放在主機記憶體裡,8B 骨幹的吞吐只降 2.8%;論文第 2.5 節建議把長尾放到 NVMe SSD 上。https://arxiv.org/abs/2601.07372 ↩ ↩2

  20. The path to ubiquitous AILjubisa Bajic · Taalas · 2026-02taalas.com ↗HC1 把 Llama 3.1 8B 硬連線進晶片,3 位和 6 位混合量化,單使用者 17K token/s;保留上下文長度配置和 LoRA 微調。https://taalas.com/the-path-to-ubiquitous-ai/ ↩

延伸閱讀