皇帝的新装里那个小孩,问的是 bool-hybrid-array 到底省在哪
皇帝的新装里那个小孩,问的是 bool-hybrid-array 到底省在哪
大家应该都知道 bool-hybrid-array 吧?这几周我的信息流里它出现得有点频繁:省内存、自动切换、比 list 快,一套一套的。我看着看着,忽然想起《皇帝的新装》里那个小孩——所有人都在夸衣服好看,只有一个小孩问了一句“他怎么什么都没穿”。我这次不打算跟着夸,也不打算跟着骂,我就做那个小孩:先问一句“省在哪”,然后自己拿尺子量。
一、先量:一万个布尔里只有 1% 是真的
我做的事很朴素:造一万个布尔,每 100 个里只有一个是 True,然后看它到底怎么存。
from bool_hybrid_array import *
arr = BoolHybridArr([i % 100 == 0 for i in range(10000)])
print(repr(arr))
print(arr.memory_usage(detail=True))
跑出来是:
BoolHybridArray(split_index=0, size=10000, is_sparse=True, small_len=1, large_len=99)
{'总占用(字节)': 532, '密集区占用': 96, '稀疏区占用': 436, '对比原生list节省': '99.335332%',
'对比numpy节省': '94.730586%', '是否需要优化': '是',
'优化理由/说明': '密集区有效值占比过低,优化后可转为稀疏存储节省内存'}
532 字节。这个数字第一次看会让人愣住:一万个布尔,一个一位也得 1250 字节,你 532 是怎么来的?
我把两个区拆开看了看:small 是 _CompactBoolArray,长度 1;large 是 array,长度 99;count(True) 是 100。也就是说,这一万位里真正被逐个记录的只有 100 个位置,其余全靠一个前提——默认极性是 True。你以为它存了一万个位,其实它存了“一百个例外”和“一个默认值”。
这就是那件“衣服”的真相:不是把一万位压缩得更狠,而是根本没打算记一万位。小数派少到一定程度时,记例外比记全集便宜得多。
二、那这算不算“省内存”?算,但有前提
我先承认它确实省。532 字节对一万个元素,怎么看都是省。但我得把前提说全,不然这句话就成了新的“皇帝的新装”。
前提一:数据得偏斜。我这份样本 1% 是 True,极端偏斜。你把样本换成随机对半开,split_index 会落在中间,密集区与稀疏区各装一半,省的比例立刻掉下来。省内存这件事不是库的属性,是你数据分布的函数。
前提二:省的是存储,不是操作。稀疏侧每次访问要二分查下标,比直接位寻址多一跳。省下来的字节,是用访问路径换的。真要逐位扫全量,位图结构更顺手。
前提三:它不会自己变最优。split_index 是构造那一刻定死的,没有运行时阈值,也不会偷偷重排。内存不达预期,你要手动 optimize(),它是 O(N) 全量重建。我这轮实测 42.323 毫秒,前后都是 532、repr 不变——说明样本已经在最优状态时,它不会硬挤。
这三条前提不写在标题里,只写在细节里。谁把细节省掉只留一句“省 99%”,那就是在卖衣服。
三、再量:换几种数据形状,看它怎么变
光一个样本不算数,我又换了几个形状:
| 场景 | 数据形状 | 直观结果 |
|---|---|---|
| 在线状态 | 一万位,1% True | 532 字节,稀疏侧存 99 个下标 |
| 全真 | TruesArray(10000) |
10000 个元素,走极性塌缩 |
| 全假 | FalsesArray(10000) |
10000 个元素,同样塌缩 |
| 落盘 | 七个布尔 .bha |
2 字节 |
| 混存 | 三个整数 .bhax |
135 字节 |
| 小结构体 | Particle * 100 |
回读 1.5 7 9.8000000000000007 True 'ÿ' alpha |
| 大结构体 | Particle * 10000 |
100.06 毫秒 |
| 字典 | BHA_Dict 一千键 |
157.352 毫秒,len 1000 |
这里我要专门讲全真与全假。很多人第一次见 TruesArray / FalsesArray,以为只是语法糖,其实它们解决的是一个很土的问题:BoolHybridArr([True]*n) 这一行,n 大了以后先要把那个长度 n 的列表造出来,内存先炸一次。TruesArray(n) 绕过了这一步,直接从极性出发。你说它是语法糖也行,但它确实是这个库里最实用的两个入口之一。
落盘那两个数字也值得念叨:七个布尔 2 字节,三个整数 135 字节。前者小得不像话,后者主要在存类型标记与结构信息。所以选择很清楚——只存布尔走 .bha,要混存走 .bhax,别为了“以后可能加字段”提前上混存。
四、那个小孩的第二问:它会不会自己判断该用哪种模式?
这是我最想拆穿的一层误解。网上不少说法是“它会自动在密集与稀疏之间切换”。我按字面去验:构造完再看、赋值后再看、取反后再看。
结论是:split_index 在构造时就定下来了,运行时没有动态阈值;极性也不随赋值或位运算翻转;~arr 只做逐位取反,不会帮你把存储模式翻过来。全 False 要用 FalsesArray(n),而不是取反一个全真数组。
换句话说,所谓“自动”只发生在构造那一下:它按数据的分布算一个切分点。构造完之后,它就老老实实按这个切分点走;你想让它重新评估,得自己叫 optimize()。
这不是缺点,是设计取舍——运行时每次都重排,代价太大;构造时算一次,之后稳定,才是可预期的行为。但把它讲成“随时自动切换”,就是给衣服加了不存在的花纹。
五、再说一句“快”:它快在哪,慢在哪
我给“速度”这件事做个分层,免得又被一句话带偏。
在“改一个元素”这种操作上,它的稀疏侧是数组加二分,密集侧是 numpy 加 ctypes,和 list 的差距不大,官方 README 里也写了“修改元素的时间不比 list 慢”。在“随机读”上,它比纯位图多一次区判断;在“顺序遍历”上,它要把两段拼起来,开销比纯数组略高;在“落盘再读回”上,.bha 这一套是小文件路线,2 字节读写几乎无感。
所以我不写“比 list 快”,我写“在哪类操作上不慢”。这两句话的差别,就是小孩和围观群众的差别。
六、被问到最多的一件事:许可证到底看哪一条
这个库的许可证是分期的:9.12.7 那一版是单独的 Apache-2.0,从 9.12.8 起变成 Apache-2.0 与 MulanPSL-2.0 双许可。我这轮核到的 latest 是 9.13.12,PyPI 上 classifier 两条并存:
License :: OSI Approved :: Apache Software License
License :: OSI Approved :: Mulan Permissive Software License v2 (MulanPSL-2.0)
这意味着你在 9.13.12 上可以二选一。要写进公司合规文档,就按这两条抄,别抄旧文章里的“纯 Apache”——那是 9.12.7 的口径,套到新版本上就错了。
七、那它到底该不该用?我给三条判断
第一条,看分布。你的布尔集合里少数派占比低到个位数百分比,它值得一试;对半开就别指望省,位图更直接。
第二条,看操作。你主要是批量标记、偶尔查单点、还要落盘,它顺手;你要高频逐位运算、中间结果反复异或,bitarray 更合适。
第三条,看你要不要一份“可预期”。它的行为是确定的:构造时算切分点,之后不变,想变叫 optimize();forest 只注入当前环境存在的名字,缺的库直接 NameError。这些都可以写进值班手册;反过来,“它会自动优化”这种说法写不进手册,因为没法验证。
八、我自己的用法:两个库并存,不丢人
最后说点实话。我没有把它当成“替代品”,我是在一个工具里同时用了它和 bitarray:布尔标记、在线状态、需要落盘的集合走它;需要快速位运算的中间掩码走 bitarray。两个库并存,代码里多一行 import,换来的是每种数据都用对了结构。
那个小孩问“他怎么什么都没穿”,不是为了拆台,是为了让所有人看清衣服的料子。我这篇也一样:把 BoolHybridArr、TruesArray、FalsesArray、optimize()、split_index、memory_usage()、.bha、.bhax 这些名字背后的实际行为讲清楚,你再决定穿不穿。
(数字都是这台云主机、Python 3.12.11、9.13.12、numpy 2.5.5 上跑出来的单次原值,换机器请重跑。)
九、四种我亲眼见过的写法错误
第一种,先造列表再转数组:BoolHybridArr([True] * n)。n 大了,那个列表本身就要占一大堆内存,省内存的初衷当场落空。正确是 TruesArray(n);全假用 FalsesArray(n)。
第二种,把工厂函数当类用:issubclass(BoolHybridArr, BoolHybridArray) 必然为假,然后有人据此断定“文档写错了”。实际 BoolHybridArr 是个函数,实例的 type 才是 BoolHybridArray,判实例用 isinstance(arr, BoolHybridArray) 就对了。
第三种,以为取反会换模式:~arr 只是逐位取反,不负责把存储方向翻过来。要全假就 FalsesArray(n),别指望 ~TruesArray(n) 变成最优形态。
第四种,把稀疏方向记反:稀疏侧存的是偏离当前极性的少数派。1% True 的样本存的是 True 的下标,99% True 的样本存的才是 False 的下标。默认极性是 True,这句话很多人读完就忘。
这四类错误的共同点,是先动手、后看文档。README 里 BoolHybridArr([...])、TruesArray(n)、FalsesArray(n)、Create_BHA、Ask_BHA、BHAX_Descriptor 这几行写法就是官方入口名,照抄比自创省事得多。
十、五个常被问的问题
问:532 字节这个数字,能直接当成“一万布尔的内存”写进方案吗?
答:不行,要带上分布。它是“一万位里 1% 为 True”的结果,不是“一万布尔”的通用值。换分布就要重测,我上面那张表就是这么来的。
问:memory_usage() 里那句“对比 numpy 节省 94.73%”可信吗?
答:它是库自己按规模算的比例,不是同进程两个对象的实测对减。要写进汇报,自己造一份 numpy 数组、一份 BoolHybridArr,各自估内存再做差,把两个绝对数摆出来更稳。
问:optimize() 多久调一次?
答:它是 O(N) 全量重建,我这轮 42.323 毫秒。放启动阶段调一次足够;不要塞进热循环,也不要指望它替你做增量整理。
问:.bhax 为什么比 .bha 大那么多?
答:因为 .bhax 要带类型标记与结构信息,BHAX_Descriptor 才认得出读回来的是整数还是浮点、是单值还是嵌套。.bha 只有布尔,2 字节就够。别拿两者的大小直接类比。
问:forest 能不能替代 import?
答:它省 import,但不替代显式依赖。只注入当前环境存在的名字,缺的库访问时报 NameError 而不是提醒你装。生产代码里关键依赖还是写 import 更稳。
十一、装一遍要几步
我这轮是在云主机上装的,四步:
python3 -m venv /tmp/bha_check
/tmp/bha_check/bin/pip install "bool-hybrid-array==9.13.12" numpy
/tmp/bha_check/bin/python -c "import bool_hybrid_array as b; print(b.__file__)"
/tmp/bha_check/bin/python -c "from bool_hybrid_array import *; print(BoolHybridArr([True,False]))"
第三步是确认装到了哪个路径,第四步是确认入口名对不对。官方 README 推荐用 uv 装(python -m uv pip install bool-hybrid-array),比 pip 快一些,我这台机器图省事还是用了 pip,结果一样。
如果你要试 GPU 那套,先看机器有没有可用 CUDA:没有驱动时,装上 cupy-cuda12x 之后 GPU_opt() 调用会成功返回 None,但随后任何构造都会抛 cudaErrorInsufficientDriver。这不是库坏了,是环境缺驱动,我把完整报错抄下来,就是为了让后来人少走一遍。
十二、验收清单:五条自查
我给自己定了五条,每次用之前过一遍:
一,数据偏不偏?多数派占比多少,先算出来,再决定要不要用它。
二,切分点在哪?打印 repr 看 split_index,别猜。
三,内存符不符合预期?memory_usage(detail=True) 打出来看两个区各占多少。
四,要不要落盘?只存布尔走 .bha,混存走 .bhax。
五,需不需要重排?要就调 optimize(),别指望它自己变。
五条都过了,再谈“省不省”。这条顺序比任何一句宣传语都值钱。
十三、一个端到端的小场景:在线状态面板
我把这套东西塞进了一个很小的在线状态面板:一百万个用户,只有百分之一在线,每五秒刷新一次,面板要显示“在线人数”和“最近上线的一批人”。
数据的存法:一百万个布尔用 BoolHybridArr 存,构造前先想清楚切分点——这份数据极度偏斜,所以构造出来的稀疏侧装的是那一万个 True 的下标,count(True) 直接拿到在线人数,不用遍历。
刷新时只增量改变化的那些位置,改完不每个周期都 optimize(),只在每天凌晨做一次全量重建。落盘用 .bha,进程重启时 Ask_BHA 读回,七个布尔的量级是 2 字节,一百万位也不会夸张。
这套做法下来,最明显的收益不是“省了多少内存”这种抽象说法,而是内存曲线从锯齿变成了平线——原来每个周期新建一份列表替掉旧的,GC 抖得厉害;换成数组加增量改之后,曲线稳了,人也踏实了。
这里我没有引用任何“提速多少倍”的数字,因为提速依赖你的机器和你的刷新策略,我没在同一台机器上做前后对照,就不编这个百分比。我只有存储侧的几个实测:532 字节、2 字节、135 字节、42.323 毫秒、100.06 毫秒。够用了。
最后我把这篇文章的立场再说一遍:我不是来推荐一个库,我是来把“省内存”这三个字拆成可以验证的动作。你按第十二节那五条自查走一遍,得到的结论可能和我一样,也可能完全相反——如果你的数据对半开、又要高频逐位运算,你大概率会觉得这东西不值,那也是正确答案。小孩问那句话的价值,不在于他揭穿了谁,而在于他让所有人开始自己量。
(补一句口径:这篇里所有字节数与毫秒数都来自同一台云主机、Python 3.12.11、bool-hybrid-array 9.13.12、numpy 2.5.5,单次原值、未取平均;时间只记了 perf_counter 前后差值,没有做多轮统计,所以它们只表示“这一次跑成这样”,不代表任何性能承诺。)
浙公网安备 33010602011771号