被三个审稿人轮番唱衰之后,我把 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,这一点我测过。文档与代码不一致的地方,以实跑为准,并且要在文里写明差异——这条我以前吃过教训,现在每次都单独标出来。

posted @ 2026-11-19 14:12  贝壳bkshell  阅读(0)  评论(0)    收藏  举报