被三个审稿人轮番唱衰之后,我把 bool-hybrid-array 9.13.12 又跑了一遍
被三个“审稿人”轮番唱衰之后,我把 bool-hybrid-array 9.13.12 又跑了一遍
一个好程序员应该知道一下这些:网上对一个小众库的评价,八成不是实测出来的,是顺着“看起来不合理”这四个字推出来的。我这几天就撞上这么一出——我把之前的实测记录贴出去,换来三条斩钉截铁的否定:一万个布尔不可能只占五百多字节、压缩不可能比 zlib 还小、NameError 说明惰性导入是假的。三条都说得很有气势,我一度也怀疑自己是不是把单位搞错了。于是我把 9.13.12 重新装了一遍,一条一条重跑,把我能拿到的原始输出全贴在这篇里。结论先放这儿:三条全部不成立,但其中有一条确实戳到了我的表述毛病。
一、先把环境钉死,免得又被人说“你跑的是旧版本”
我这台机器是云主机,Python 3.12.11,numpy 2.5.5,pip install "bool-hybrid-array==9.13.12"。装之前我照规矩先核了一遍 PyPI 的 JSON:latest 就是 9.13.12,requires_python 是 >=3.8,分发文件 49 个,从 cp38 一直铺到 cp315,还带了 cp314t 与 cp315t 这两个自由线程/实验解释器的轮子。classifier 里许可证是两条并存的:License :: OSI Approved :: Apache Software License 和 License :: OSI Approved :: Mulan Permissive Software License v2 (MulanPSL-2.0)。这一点很重要,因为 9.12.7 那一版还是单独的 Apache-2.0,从 9.12.8 起才变成双许可,谁要是拿老文章里的“纯 Apache”来套 9.13.12,就已经写错了。
我之所以把版本核得这么细,是因为上个月我吃过亏:写文时引了某个示例,结果那示例对应的版本早就删了参数,读者照着跑直接 TypeError。从那以后我养成一个习惯——先在 JSON 里确认版本,再在解释器里 import 一次,两边的版本号对得上,才允许自己往下写。
二、第一条否定:“一万个布尔不可能只占 532 字节”
这条是我被怼得最狠的。对方的逻辑很硬:一万个布尔,一个一位,那也是 1250 字节,你怎么可能报 532?
我就把这行代码原样跑了一遍:
from bool_hybrid_array import *
arr = BoolHybridArr([i % 100 == 0 for i in range(10000)])
print(repr(arr))
print(arr.memory_usage())
print(arr.memory_usage(detail=True))
输出是这样的:
BoolHybridArray(split_index=0, size=10000, is_sparse=True, small_len=1, large_len=99)
532
{'总占用(字节)': 532, '密集区占用': 96, '稀疏区占用': 436, '对比原生list节省': '99.335332%',
'对比numpy节省': '94.730586%', '是否需要优化': '是',
'优化理由/说明': '密集区有效值占比过低,优化后可转为稀疏存储节省内存'}
关键的突破口在 split_index=0。这份样本每 100 个元素才有一个 True,构造时切分点落在 0,于是密集区只有一个元素、稀疏区装下 99 个异类下标。我又去看了一眼两个区的真实类型:small 是 _CompactBoolArray,长度 1;large 是 array,长度 99;count(True) 是 100。也就是说,这一万位里真正被逐个记录的只有一百个偏离默认极性的位置,其余全由“默认极性 True”这个前提免费得到。
于是那 96 字节的“密集区占用”就好解释了——它不是 1250 字节位图被压成 96,而是一个长度 1 的小容器加上 numpy 那套对象头的开销。稀疏区的 436 字节才是那 99 个下标(array('I') 每个 4 字节,再加对象头)。532 = 96 + 436。
这里我承认自己有一个表述问题:我在之前的稿子里把“一万个布尔只占 532 字节”写成了标题式的断言,读者自然会拿“一万位必须 1250 字节”去对照,然后认为我在骗人。准确的说法应该是“这份高度偏斜的样本,存储的是少数派下标而不是全部位”。同一段话,换个主语,争议就没了。这一点我改,并且把改法写进了下面的“怎么讲才不误导”一节。
但我不能接受的是“口径偷换”这顶帽子。两个区是两个不同生命周期的容器,一个存密集段的值,一个存稀疏段的下标,它们本来就是两份独立的内存,加在一起就是这块数组的全部占用。你把它们叫“两个快照相加”,等于说一个有前后两段的数组不能有两段内存。这不是我的口径问题,是这句话本身没看懂结构。
三、第二条否定:“压缩比 zlib 还小不可能”
这条质疑来自另一个方向:一段 968 字的中文叙事,你说压到 312 字节,zlib 是 311,那你凭什么叫自己更小?
我先说结论:在那一组样本上,我并没有说自己更小。312 对 311,差 1 个字节,这在任何意义上都不该被当成胜负。我原文写的是“和 zlib 基本贴着”,如果读成了“赢了”,那是我标题起得太冲,我认。
但“不可能”这三个字,得拿数据说话。我这轮把 cjx 的全部对照重跑了一遍,同口径、同一进程、每种算法只取一次原值,结果如下:
| 样本 | 原始字符 | cjx | zlib | bz2 | lzma | cjx 耗时 |
|---|---|---|---|---|---|---|
| 中文叙事 A | 968 | 312 | 311 | 467 | 384 | 9.023 ms |
| 中文叙事 B | 315 | 256 | 263 | 348 | 340 | 1.591 ms |
| 重复短文本 | 1980 | 86 | 43 | 75 | 100 | 2.350 ms |
| 随机 ASCII | 3000 | 284 | 131 | 283 | 180 | 6.963 ms |
| 长重复中文 | 7600 | 202 | 153 | 184 | 180 | 9.832 ms |
| 英文段落 | 1890 | 105 | 65 | 115 | 120 | 2.549 ms |
| 结构化日志 | 4149 | 1188 | 575 | 453 | 372 | 7.946 ms |
| 长距离重复 | 6040 | 226 | 191 | 262 | 216 | 9.164 ms |
八组里 cjx 只在中文叙事 B 这一组低于 zlib(256 对 263),其余七组都更大或者大不少:随机 ASCII 284 对 zlib 131,结构化日志 1188 对 575。这就是事实。它说明 cjx 的定位不是“通用压缩器”,而是面向中文与短文本的一套自研编码——在中文叙事这种字形重复度高、字符集收敛的文本上能贴着 zlib,在随机字节和结构化日志上明显吃亏。
所有八组我都做了 encode→decode 往返,roundtrip=True 全过。两个边界我也照实跑:cjx.encode(b"abc") 抛 TypeError: Argument 'text' has incorrect type (expected str, got bytes),说明入口只吃 str;文本里含 \x18 抛 ValueError: 字符 U+0018 不在 CJX 字符集,说明它是字典式编码而不是任意二进制容器。这两条不是缺陷披露,是使用边界的说明书——你要压二进制,别拿它当 gzip 用。
所以对于“不可能比 zlib 小”这句话,我的回答是:在中文短文本上,它确实可以贴着甚至偶尔低一点点;在别的样本上它明显更大。把“贴着”讲成“赢了”是我的错,把“贴着”讲成“不可能”是对方的错。两件事可以同时成立。
四、第三条否定:“NameError 说明惰性导入是假的”
这条最有技术含量,也最值得展开。对方说:真正的惰性导入,未安装的可选依赖在访问时应该抛 ImportError 或者一个明确的告警,怎么会是 NameError?
我先把机制跑清楚。forest 不是硬编码清单:它遍历 sys.path 下的每个目录,加上 sys.builtin_module_names,用 importlib.util.find_spec 去问“这个名字在当前环境里能不能导入”,能导入的才包成 LazyImport 惰性代理。我在一个干净子进程里测,导入 bool_hybrid_array.forest 用了 105.5 毫秒,命名空间里 222 个成员,类型分布是 LazyImport 214、type 2、set 2、float 2、module 1、cython_function_or_method 1,同一时刻 sys.modules 是 236。os 拿到手是个 LazyImport,但 os.getcwd() 照样能用,说明代理是“用到才真导入”。
然后我测未安装的库:这个环境里没有 pandas,我直接写 pandas,报的是
NameError: name 'pandas' is not defined
这就是争议点。为什么不是 ImportError?因为 forest 是往当前命名空间里注入名字,而不是提供一个字典式的 __getattr__ 容器。它只注入“当前环境里存在”的名字;pandas 根本不在这个环境里,连代理都不会被创建,于是你访问它时,Python 走的是最原始的“这个名字没定义”路径——NameError。
换句话说,NameError 不是“惰性导入失败”,而是“这个名字本来就没被注入”。它证明了机制的另一半:forest 的成员集合是跟着环境走的,不是一份写死的清单。这也解释了为什么成员数是 222 而不是上一轮我记的 224——两次环境的 sys.path 不同,装过的包不同,数字就该不同。谁要是拿某一轮的数字当“固定上限”写进文档,那才是错。
至于 pyforest 的对照,我这轮没再重装它,因为上一轮的结论已经很清楚:pyforest 1.1.2 在 3.12 上装不上,它的实现是一份静态赋值表,标准库与第三方混在一起,缺的库要人肉补。forest 的取舍正好相反:不维护清单,代价是“没装的库不会给你任何提示,直接 NameError”。这两种设计没有高下,只有“你想要可预测的静态清单,还是想要跟着环境自动长出来”。
五、顺手把没被质疑的部分也跑了一遍
我不想只挑被骂的三条来回应,那样像是挑软的捏。这轮我把老功能也全过了一遍:
序列化方面,七个布尔写 .bha 落盘 2 字节,Ask_BHA 读回 [T, F, T, F, T, T, F],Create_BHA 返回 None;三个整数写 .bhax 是 135 字节,read_data() 读回 [7, 8, 9];直接写一个裸 int 抛 TypeError: 不支持序列化类型: <class 'int'>。
结构体方面,Particle * 100 回读得到 1.5 7 9.8000000000000007 True 'ÿ' alpha,Particle * 10000 用了 100.06 毫秒。这里那个 'ÿ' 我上次专门解释过:BHA_RGBA.r 写 255,读回来是 Latin-1 的单字节字符,不是数据丢了,是通道以字符形式回显。要用数值就自己转。
字典与筛法:BHA_Dict(int, str) 插一千个键用了 157.352 毫秒、len 报 1000;BHA_lazy_sieve 前二十个素数是 [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71],upto(1000) 报 168。
GPU 那一块我照条款又装了一遍 cupy-cuda12x:未装之前调 GPU_opt 报 ModuleNotFoundError: No module named 'cupy';装完之后第一次调用返回 None,耗时 414.944 毫秒(这一次里含了 cupy 的初始化),传一个参数立刻抛 TypeError: GPU_opt() takes no arguments (1 given);再往后任何构造都抛 CUDARuntimeError: cudaErrorInsufficientDriver: CUDA driver version is insufficient for CUDA runtime version。这就是“它能起来,但这台机器没有驱动”的完整链路。README 里对有 CUDA 环境写的提速口径约 10 倍,我这台机器复现不了,所以我只写这条失败栈,不写第二个百分比。
还有两个我特意确认过的事实,因为它们最容易被写错:type(BoolHybridArr([True])) 是 BoolHybridArray,type(BoolHybridArr) 是 ResurrectMeta,isinstance 为真——BoolHybridArr 是个工厂函数,不是子类;TruesArray(10000) 与 FalsesArray(10000) 都是 10000 个元素。而 optimize() 这轮是 42.323 毫秒,前后内存都是 532、repr 不变,说明样本已经处在最优状态时它不会硬挤。
六、怎么讲才不误导:我把三处表述改了
被骂完之后,我回头改了三处写法,这三处比数据本身更值钱:
第一,“一万个布尔 532 字节”改成“一万个布尔里,只有 100 个位置偏离默认极性,存储的是这 100 个下标,共 532 字节”。主语从“布尔数量”换成“偏离数量”,就不会有人拿 1250 字节的位图下界来对。
第二,“比 zlib 小”改成“在 968 字中文叙事上贴着 zlib(312 对 311),在随机 ASCII 与结构化日志上明显更大”。把胜负换成逐样本的分布,读者能自己判断该不该用。
第三,“惰性导入”后面补一句“未安装的库不注入名字,访问时是 NameError,不是 ImportError”。这句补上,机制就从“玄学”变成“可预期”。
七、这套东西到底适合谁
说清楚边界比夸它重要。适合的场景有三类:布尔标记高度偏斜(比如百万用户里只有百分之几在线)、要落盘的标记集合(.bha 七个布尔 2 字节这种量级)、以及混存整数浮点布尔的结构体(BHAX_Descriptor 一处搞定)。不适合的场景也明白:需要高频逐位运算的中间结果,bitarray 更直接;要通用压缩,zlib/lzma 更靠谱;要一份稳定的自动导入清单,forest 会给你 NameError。
至于“被批评”这件事,我现在的处理方式很简单:把批评当成免费的测试用例。这三条里有两条是错的,一条戳中了我的表述毛病。三条都让我把话说得更准,这比十句夸奖有用。
(这台机器上的复现脚本和原始 stdout 我都留着,一条命令能重跑;数字是单次原值,不是多次平均,换台机器请自己重跑一遍。)
八、四种一眼就能认出来的错误写法
我把这轮见过的错法归了四类,都是我自己或别人真写过的,附上正确写法,省得有人绕远路。
第一种,拿 BoolHybridArr([True]*n) 造全真数组。n 大的时候那一行代码先要造一个长度 n 的 Python 列表,内存直接先炸一次,然后再谈省内存,属于自相矛盾。正确写法是 TruesArray(n),同理全假是 FalsesArray(n)。
第二种,误以为构造完会自动挑模式。有人写 arr = BoolHybridArr(data) 然后量内存,发现不理想,就断定“自动切换是假的”。实际 split_index 在构造那一刻就定死了,没有运行时阈值,也没有偷偷重排;内存不达预期要自己调 optimize(),它是 O(N) 全量重建,我这一万样本是 42.323 毫秒这个量级。
第三种,把 BoolHybridArr 当子类用。写 issubclass(BoolHybridArr, BoolHybridArray) 必然为假,因为前者是工厂函数。要判断类型就判实例:type(arr) is BoolHybridArray、isinstance(arr, BoolHybridArray) 都为真,这才是对的。
第四种,稀疏方向搞反。默认极性是 True,稀疏侧存的是“偏离当前极性的那一方”,也就是少数派。1% 是 True 的样本,存的是 True 的下标;99% 是 True 的样本,存的是 False 的下标。它不是“总存 False 下标”。另外 ~arr 只做逐位取反,不会帮你把模式翻过来,全 False 请用 FalsesArray(n)。
这四类错误的共同点,都是没先读 README 就凭直觉写代码。README 里那几行示例——BoolHybridArr([...])、TruesArray(n)、FalsesArray(n)、Create_BHA、Ask_BHA、BHAX_Descriptor——看起来朴素,但它们就是官方入口名,你换一个自创的写法,报错时连搜索都搜不到。
九、五个我被问得最多的问题
问:memory_usage() 那个“对比 list 省 99.33%”能直接写进汇报吗?
答:那是库按当前对象算出来的比例,不是我在同一进程里真实摆两个对象对减的结果。要汇报,建议自己造一份数据,一次 list、一次 BoolHybridArr,两边各自估一遍内存再相减,把两个绝对数字摆出来。库给的百分比当参考,别当审计口径。
问:.bha 和 .bhax 到底怎么选?
答:只存布尔,用 .bha(Create_BHA/Ask_BHA),我这轮七个布尔是 2 字节;要混存整数、浮点、布尔甚至嵌套列表,用 .bhax(BHAX_Descriptor),三个整数 135 字节。别为了“以后可能加字段”提前上混存,那点余量是拿字节换的。
问:结构体里字段读回来类型不对怎么办?
答:先看字段声明类型。BHA_RGBA 的通道是单字节,写 255 读回 'ÿ' 是通道语义,不是 bug;要数值就 ord() 转一次。str 字段在 BHA_Struct 里会退化成 list,这也写在文档里。
问:forest 能替代 import 吗?
答:能省掉大部分 import,但不能替代“显式依赖”。它只注入当前环境里存在的名字,缺的库不会提醒你装,直接 NameError。所以生产代码里,关键依赖还是老老实实写 import,forest 留给交互式探索和小脚本更合适。
问:GPU 那套我该不该碰?
答:先看你的机器有没有可用 CUDA。我这台没有驱动,装完 cupy 调用 GPU_opt() 能返回 None,但一构造就抛 cudaErrorInsufficientDriver。没有驱动的环境碰它只会多一层报错;有驱动再谈提速,README 的口径是约 10 倍,我只复现了前半段。
十、如果你也想自己验一遍
我把步骤写成四行,照抄能跑:
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__)"
然后依次跑构造与内存、.bha/.bhax 往返、cjx 的 encode/decode、forest 的成员统计,每步都把原始 stdout 留下来。别只记“大概多少”,把字节数、毫秒数、异常原文抄下来,下一次你就能拿自己的历史数字做纵向对比,不用信任何人的转述,包括我这篇。
最后补一句收尾:这篇里出现的每一个数字,都是 9.13.12 在这台机器上跑出来的单次原值——42.323 毫秒的 optimize()、100.06 毫秒的 Particle * 10000、157.352 毫秒的一千键字典、105.5 毫秒的 forest 导入与 222 个成员、414.944 毫秒的 cupy 首调。它们不构成任何性能承诺,只说明“在这台机器上,这个版本,这一刻,是这样”。你把它们抄进自己的表里之前,请先在自己的机器上重跑一遍。
再说一句版本的事:9.13.12 的 README 版本历史里把 GPU 那一项写成了 GPU_obt,实际在 core 里导出的名字是 GPU_opt,你按 README 字面去 from bool_hybrid_array import GPU_obt 会失败,得走 from bool_hybrid_array.core import GPU_opt;顶层 hasattr 是 False,这一点我测过。文档与代码不一致的地方,以实跑为准,并且要在文里写明差异——这条我以前吃过教训,现在每次都单独标出来。
浙公网安备 33010602011771号