Update bilingual model cards and benchmark figures

Browse files

Files changed (10) hide show

.gitattributes +5 -0
README.en.md +33 -22
README.md +72 -59
README.zh-CN.md +33 -22
benchmark_case_epyc.json +62 -0
bit-jev-case-memory.en.png +3 -0
bit-jev-case-memory.zh-CN.png +3 -0
bit-jev-case-speed.en.png +3 -0
bit-jev-case-speed.zh-CN.png +3 -0
bit-jev-logo.png +3 -0

.gitattributes CHANGED Viewed

@@ -43,3 +43,8 @@ project-cover.zh-CN.png filter=lfs diff=lfs merge=lfs -text
 decision-engine.png filter=lfs diff=lfs merge=lfs -text
 project-flow.en.png filter=lfs diff=lfs merge=lfs -text
 project-flow.zh-CN.png filter=lfs diff=lfs merge=lfs -text

 decision-engine.png filter=lfs diff=lfs merge=lfs -text
 project-flow.en.png filter=lfs diff=lfs merge=lfs -text
 project-flow.zh-CN.png filter=lfs diff=lfs merge=lfs -text
+bit-jev-logo.png filter=lfs diff=lfs merge=lfs -text
+bit-jev-case-speed.zh-CN.png filter=lfs diff=lfs merge=lfs -text
+bit-jev-case-speed.en.png filter=lfs diff=lfs merge=lfs -text
+bit-jev-case-memory.zh-CN.png filter=lfs diff=lfs merge=lfs -text
+bit-jev-case-memory.en.png filter=lfs diff=lfs merge=lfs -text

README.en.md CHANGED Viewed

@@ -14,18 +14,18 @@ tags:
 # bit-jev-2b-distilled
-[中文模型卡](README.zh-CN.md) · [Source repository](https://github.com/Zeaulo/bit-jev) · [pip package](https://pypi.org/project/bit-jev/)
-![bit-jev ternary inputs, decision engine, and scored options](decision-engine.png)
-Install the package and run its built-in example:
 ```bash
-python -m pip install --upgrade bit-jev
-bit-jev-demo
 ```
-The first run downloads the roughly 1.19 GB model; later runs reuse the cache. Use `bit-jev-demo --device gpu` for Vulkan. The demo prints an actual prediction, not a fixed sample answer.
 ![bit-jev training, distillation, quantization, and CPU/Vulkan inference](project-flow.en.png)
@@ -70,37 +70,48 @@ This release contains the I2_S artifacts for the native CPU runner, matching tok
 ## Inference
-Install the Python package. On Windows x64 with an AVX2 CPU, the bit-jev 0.11.10 wheel includes precompiled CPU and Vulkan GPU runners. For `device="cpu"` or `device="gpu"`, inference needs no Git, CMake, compiler, or Vulkan SDK. Vulkan needs a compatible graphics driver that supplies `vulkan-1.dll`. The roughly 1.19 GB model still downloads on first use. Other platforms and CUDA build from pinned source and require Git, CMake 3.28+, and a C++17 compiler; CUDA needs the CUDA Toolkit.
-```bash
-pip install bit-jev
-```
 ```python
-from bit_jev import BitJev
-request = {"state": "A customer reports a duplicate charge.", "questions": {"team": {"type": "choice", "instructions": "Which team should handle it?", "criteria": {"billing": "Payment and refunds", "shipping": "Delivery"}}}}
 with BitJev.from_pretrained(device="cpu", threads=8) as model:
-    print(model.infer(request)["answers"])
 ```
 `device="gpu"` selects Vulkan; `device="cuda"` selects a CUDA build. `infer()` reuses the resident model. See the [GGUF package guide](https://github.com/Zeaulo/bit-jev/blob/main/docs/GGUF_PACKAGE.md) for CLI, offline directories, and build details. This model repository contains model files; both precompiled runners are distributed in the PyPI Windows x64 wheel.
-## AutoDL case study: Xeon Gold 6459C / RTX 5090
-The measurements below use one fixed development request with 703 input tokens and 77 options. Inference timing excludes model loading. CPU uses the native I2_S path; GPU uses an experimental FP16 mixed-precision PyTorch path. These GPU numbers do not benchmark the new pip package's GGUF/Vulkan or GGUF/CUDA path.
 | Path | Mean inference time | Repetitions | Observed memory |
 | --- | ---: | ---: | ---: |
-| CPU, 8 threads | 3,127.88 ms | 3 | 1,622.74 MiB peak process RSS |
-| CPU, 16 threads | 1,972.17 ms | 3 | 1,624.52 MiB peak process RSS |
-| RTX 5090 | 86.56 ms | 5 | 4,935.53 MiB peak GPU allocation |
-![bit-jev AutoDL single-question latency and memory](bit-jev-autodl-case.en.png)
-[中文图表](bit-jev-autodl-case.zh-CN.png)
-For this one request, the 16-thread CPU to RTX 5090 latency ratio is about 22.8. The paths use different weight formats and numeric precision, so this is not an isolated hardware speedup. CPU RSS and GPU allocation are different measures. This small case study is not a general throughput or accuracy claim. Sanitized timings are in `benchmark_case_autodl.json`; the input, options, and predictions are not included. Generated tokens/s does not apply because the model scores options and emits structured decisions. No auditable held-out report for accuracy, Brier, NLL, or ECE is available, so no such values are claimed.
 ## Data provenance and use

 # bit-jev-2b-distilled
+[中文模型卡](README.md) · [Source repository](https://github.com/Zeaulo/bit-jev) · [pip package](https://pypi.org/project/bit-jev/) · [ModelScope mirror](https://www.modelscope.cn/models/JingHao9616/bit-jev-2b-distilled)
+![bit-jev binary trail and accelerating rocket logo](bit-jev-logo.png)
+On Windows x64 with Python 3.11/3.12, install the current release with the interpreter that will run inference, then check the distribution version and import path:
 ```bash
+python -m pip install --upgrade --no-cache-dir bit-jev==0.12.10 -i https://pypi.org/simple
+python -c "from importlib.metadata import version; import bit_jev; print(version('bit-jev'), bit_jev.__file__)"
 ```
+The version should be `0.12.10`, and the import path should point into the active environment's `site-packages/bit_jev`. Then run the Python example below, which does not depend on the `bit-jev-demo` console script being on PATH. The first model load downloads roughly 1.19 GB; later runs reuse the cache. The default first tries Hugging Face and falls back to ModelScope if the connection fails. Use `source="modelscope"` to select ModelScope directly. See the [install guide](https://github.com/Zeaulo/bit-jev/blob/main/docs/GGUF_PACKAGE.md) for stale mirrors and mixed environments.
 ![bit-jev training, distillation, quantization, and CPU/Vulkan inference](project-flow.en.png)
 ## Inference
+Install the Python package. On Windows x64 with an AVX2 CPU, the bit-jev 0.12.10 wheel includes precompiled CPU and Vulkan GPU runners. For `device="cpu"` or `device="gpu"`, inference needs no Git, CMake, compiler, or Vulkan SDK. Vulkan needs a compatible graphics driver that supplies `vulkan-1.dll`. The roughly 1.19 GB model still downloads on first use. Other platforms and CUDA build from pinned source and require Git, CMake 3.28+, and a C++17 compiler; CUDA needs the CUDA Toolkit.
 ```python
+from bit_jev.gguf import BitJev
+request = {
+    "state": "A customer reports a duplicate charge on the same order.",
+    "questions": {
+        "team": {
+            "type": "choice",
+            "instructions": "Which team should handle it?",
+            "criteria": {"billing": "Payment and refunds", "shipping": "Delivery"},
+        }
+    },
+}
 with BitJev.from_pretrained(device="cpu", threads=8) as model:
+    result = model.infer(request)
+    print(result["answers"])
+    print(result["latency_ms"])
 ```
 `device="gpu"` selects Vulkan; `device="cuda"` selects a CUDA build. `infer()` reuses the resident model. See the [GGUF package guide](https://github.com/Zeaulo/bit-jev/blob/main/docs/GGUF_PACKAGE.md) for CLI, offline directories, and build details. This model repository contains model files; both precompiled runners are distributed in the PyPI Windows x64 wheel.
+## AutoDL case study: EPYC 9654 CPU and RTX 5090 on another host
+The measurements below use one fixed development request with 703 input tokens and 77 options. Native inference timing excludes model loading. The latency chart pairs a new EPYC 9654 container measurement with a 32-core quota and 32 native I2_S threads with a historical RTX 5090 FP16 mixed-precision PyTorch path from another host. The memory chart retains the original same-host Xeon Gold 6459C / RTX 5090 observations. These GPU numbers do not benchmark the pip package's GGUF/Vulkan or GGUF/CUDA path.
 | Path | Mean inference time | Repetitions | Observed memory |
 | --- | ---: | ---: | ---: |
+| EPYC 9654, 32-core quota / 32 threads, I2_S | 1,954.46 ms | 6 | 1,625.88 MiB peak process RSS |
+| Xeon Gold 6459C, 8 threads (historical) | 3,127.88 ms | 3 | 1,622.74 MiB peak process RSS |
+| Xeon Gold 6459C, 16 threads (historical) | 1,972.17 ms | 3 | 1,624.52 MiB peak process RSS |
+| RTX 5090 on another host, FP16 | 86.56 ms | 5 | 4,935.53 MiB peak GPU allocation |
+![bit-jev AutoDL single-question inference latency comparison](bit-jev-case-speed.en.png)
+![bit-jev AutoDL peak memory comparison](bit-jev-case-memory.en.png)
+[中文图表](bit-jev-case-speed.zh-CN.png)
+On the same EPYC container, a supplemental 16-thread run averaged 3,210.12 ms, so 32 threads were about 1.64 times faster. The CPU and GPU paths in the chart ran on different hosts and used different weight formats and numeric precision; their ratio is not an isolated hardware speedup. CPU RSS and GPU allocation are different measures. This small case study is not a general throughput or accuracy claim. The [EPYC 32-thread samples](https://github.com/Zeaulo/bit-jev/blob/main/docs/benchmark-data/bit-jev-epyc9654-cpu32-2026-09-28.json) and the original same-host case in `benchmark_case_autodl.json` include no input, option text, or predictions. Generated tokens/s does not apply because the model scores options and emits structured decisions. No auditable held-out report for accuracy, Brier, NLL, or ECE is available, so no such values are claimed.
 ## Data provenance and use

README.md CHANGED Viewed

@@ -14,109 +14,122 @@ tags:
 # bit-jev-2b-distilled
-[中文模型卡](README.zh-CN.md) · [Source repository](https://github.com/Zeaulo/bit-jev) · [pip package](https://pypi.org/project/bit-jev/)
-![bit-jev ternary inputs, decision engine, and scored options](decision-engine.png)
-Install the package and run its built-in example:
 ```bash
-python -m pip install --upgrade bit-jev
-bit-jev-demo
 ```
-The first run downloads the roughly 1.19 GB model; later runs reuse the cache. Use `bit-jev-demo --device gpu` for Vulkan. The demo prints an actual prediction, not a fixed sample answer.
-![bit-jev training, distillation, quantization, and CPU/Vulkan inference](project-flow.en.png)
-The ternary symbols in the flow refer only to quantized BitLinear weights; training and inference are separate flows.
-> This repository provides the I2_S GGUF model package for bit-jev, usable with the `bit-jev` Python package on CPU or GPU. The checkpoint was trained on a multi-source decision dataset that includes Yelp review records. A request for permission covering derivative weights and metrics has been sent to Yelp; as of 2026-09-28, no written reply has been received. The Apache-2.0 license for the source repository does not automatically apply to this checkpoint.
-## Model summary
-bit-jev-2b-distilled is a structured-decision student model. An input contains a shared `state` and one or more questions. A pointer head scores explicit options and returns a choice, probabilities, or an ordered rating. It does not generate a natural-language answer token by token.
-| Type | Input | Structured output |
 | --- | --- | --- |
-| `choice` | Named options and descriptions | Selected option, scores, probabilities |
-| `noul` | Yes/no question | Scores and probabilities for both labels |
-| `score` | Ordered ratings and descriptions | Rating scores, expected value, probabilities |
-## Training and export
 ```text
 Microsoft BitNet b1.58 2B BF16
-        ↓ LoRA fine-tuning + pointer-head training
-Initial bit-jev model and pointer head
-        + candidate logits from the Kev 9B teacher
-Full-student distillation + pointer head
-        ↓ I2_S quantized export
-I2_S GGUF + float32 pointer head
 ```
-This release contains the I2_S artifacts for the native CPU runner, matching tokenizer/configuration, and pointer metadata. The recorded training configuration uses 3,144 steps, 2 epochs, BF16, learning rate `2e-5`, batch size 2, gradient accumulation 4, distillation temperature 2.0, and distillation weight 1.0. The inference-head temperature is 2.35 in `pointer.json`.
-## Files and size
-| File | Purpose | Size |
 | --- | --- | ---: |
-| `backbone-i2_s.gguf` | Quantized BitNet backbone | 1,187,288,192 bytes (about 1.106 GiB) |
-| `head.f32` | Float32 pointer head | 5,244,948 bytes |
-| `pointer.json` | Head shape, boundary tokens, and temperature | 770 bytes |
-| Tokenizer/configuration files | Request encoding and model configuration | about 17.2 MB |
-`SHA256SUMS.json` lists sizes and SHA-256 hashes for inference-package files; it does not hash itself. BF16 safetensors shards, training data, training logs, and raw reviews are not included.
-## Inference
-Install the Python package. On Windows x64 with an AVX2 CPU, the bit-jev 0.11.10 wheel includes precompiled CPU and Vulkan GPU runners. For `device="cpu"` or `device="gpu"`, inference needs no Git, CMake, compiler, or Vulkan SDK. Vulkan needs a compatible graphics driver that supplies `vulkan-1.dll`. The roughly 1.19 GB model still downloads on first use. Other platforms and CUDA build from pinned source and require Git, CMake 3.28+, and a C++17 compiler; CUDA needs the CUDA Toolkit.
-```bash
-pip install bit-jev
-```
 ```python
-from bit_jev import BitJev
-request = {"state": "A customer reports a duplicate charge.", "questions": {"team": {"type": "choice", "instructions": "Which team should handle it?", "criteria": {"billing": "Payment and refunds", "shipping": "Delivery"}}}}
 with BitJev.from_pretrained(device="cpu", threads=8) as model:
-    print(model.infer(request)["answers"])
 ```
-`device="gpu"` selects Vulkan; `device="cuda"` selects a CUDA build. `infer()` reuses the resident model. See the [GGUF package guide](https://github.com/Zeaulo/bit-jev/blob/main/docs/GGUF_PACKAGE.md) for CLI, offline directories, and build details. This model repository contains model files; both precompiled runners are distributed in the PyPI Windows x64 wheel.
-## AutoDL case study: Xeon Gold 6459C / RTX 5090
-The measurements below use one fixed development request with 703 input tokens and 77 options. Inference timing excludes model loading. CPU uses the native I2_S path; GPU uses an experimental FP16 mixed-precision PyTorch path. These GPU numbers do not benchmark the new pip package's GGUF/Vulkan or GGUF/CUDA path.
-| Path | Mean inference time | Repetitions | Observed memory |
 | --- | ---: | ---: | ---: |
-| CPU, 8 threads | 3,127.88 ms | 3 | 1,622.74 MiB peak process RSS |
-| CPU, 16 threads | 1,972.17 ms | 3 | 1,624.52 MiB peak process RSS |
-| RTX 5090 | 86.56 ms | 5 | 4,935.53 MiB peak GPU allocation |
-![bit-jev AutoDL single-question latency and memory](bit-jev-autodl-case.en.png)
-[中文图表](bit-jev-autodl-case.zh-CN.png)
-For this one request, the 16-thread CPU to RTX 5090 latency ratio is about 22.8. The paths use different weight formats and numeric precision, so this is not an isolated hardware speedup. CPU RSS and GPU allocation are different measures. This small case study is not a general throughput or accuracy claim. Sanitized timings are in `benchmark_case_autodl.json`; the input, options, and predictions are not included. Generated tokens/s does not apply because the model scores options and emits structured decisions. No auditable held-out report for accuracy, Brier, NLL, or ECE is available, so no such values are claimed.
-## Data provenance and use
-Training used the local multi-source `decision-v7` decision set, which includes Yelp review records. The repository does not contain raw Yelp records. A request for permission to publish derivative weights and metrics has been sent to Yelp; as of 2026-09-28, no written reply has been received. Downloaders should review the applicable Yelp dataset terms and their effect on derivative weights.
-**No standalone open-weights license is granted for this model.** The source repository's Apache-2.0 license, Microsoft's base-model license, and Kev's source license apply to their respective works; they do not grant rights to Yelp data or this derivative checkpoint. This card documents the project's current release status and is not legal advice.
-## Evaluation scope and limitations
-- The only public bit-jev results here are the single-request latency and memory case above. The independent Microsoft BitNet base-model benchmark measures a different model and is not a score for this checkpoint.
-- No Accuracy, Brier, NLL, ECE, or confidence interval is available across complete train/test source splits.
-- The request is a development case with few repetitions. Results do not generalize to long inputs, multi-question requests, or other hardware.
-- The native CPU runner executes one causal row per question and recomputes shared state for multiple questions.
-- Choices may depend on option wording, order, length, and training distribution. Validate on target data and retain human review for consequential decisions.
-## Citation
 ```bibtex
 @misc{bitjev2026,

 # bit-jev-2b-distilled
+[English model card](README.en.md) · [源码仓库](https://github.com/Zeaulo/bit-jev) · [pip 安装](https://pypi.org/project/bit-jev/) · [ModelScope 镜像](https://www.modelscope.cn/models/JingHao9616/bit-jev-2b-distilled)
+![bit-jev：二进制轨迹与加速火箭 Logo](bit-jev-logo.png)
+在运行推理的同一个 Python 3.11/3.12 环境中安装并核对版本：
 ```bash
+python -m pip install --upgrade --no-cache-dir bit-jev==0.12.10 -i https://pypi.org/simple
+python -c "from importlib.metadata import version; import bit_jev; print(version('bit-jev'), bit_jev.__file__)"
 ```
+版本应为 `0.12.10`，导入路径应指向当前环境的 `site-packages/bit_jev`。然后直接运行下方的 Python 示例；无需依赖 `bit-jev-demo` 命令的 PATH。首次加载会下载约 1.19 GB 模型，后续复用缓存。默认先尝试 Hugging Face，连接失败时回退 ModelScope；国内网络可在 `from_pretrained()` 中传入 `source="modelscope"`。镜像版本滞后及环境混用的处理见[安装指南](https://github.com/Zeaulo/bit-jev/blob/main/docs/GGUF_PACKAGE.zh-CN.md)。
+![bit-jev 训练、蒸馏、量化与 CPU/Vulkan 推理流程](project-flow.zh-CN.png)
+图中三值只代表量化 BitLinear 权重；训练与推理是分开的流程。
+> 本仓库提供 bit-jev 的 I2_S GGUF 模型包，可通过 `bit-jev` Python 包进行 CPU 或 GPU 推理。权重来自包含 Yelp 评论数据的多源决策训练集。Yelp 权利方许可申请已发出，截至 2026-09-28 尚未收到书面答复。本模型卡公开说明来源与限制；项目代码仓库的 Apache-2.0 许可证不自动适用于此检查点。
+## 模型简介
+bit-jev-2b-distilled 是一个结构化判断学生模型。输入包含共享 `state` 和一个或多个问题；指针头直接对输入中的候选项打分，返回选择、概率或有序等级。模型不会逐 token 生成自然语言答案。
+支持的问题类型：
+| 类型 | 输入 | 结构化输出 |
 | --- | --- | --- |
+| `choice` | 一组选项及说明 | 选择项、分数、概率 |
+| `noul` | 是/否问题 | 两类分数与概率 |
+| `score` | 有序等级及说明 | 等级分数、期望值、概率 |
+## 训练与导出流程
 ```text
 Microsoft BitNet b1.58 2B BF16
+        ↓ LoRA 微调 + 指针头训练
+bit-jev 初始模型与指针头
+        + Kev 9B 教师候选项 logits
+完整学生骨干蒸馏 + 指针头
+        ↓ I2_S 量化导出
+I2_S GGUF + float32 指针头
 ```
+发布包仅含面向原生 CPU runner 的 I2_S 产物、匹配的 tokenizer/config 和头部元数据。训练配置记录了 3,144 步、2 个 epoch、BF16、学习率 `2e-5`、批量 2、梯度累积 4、蒸馏温度 2.0 与权重 1.0。推理头温度在 `pointer.json` 中为 2.35。
+## 文件与内存规模
+| 文件 | 用途 | 大小 |
 | --- | --- | ---: |
+| `backbone-i2_s.gguf` | 量化 BitNet 骨干 | 1,187,288,192 字节（约 1.106 GiB） |
+| `head.f32` | float32 指针头 | 5,244,948 字节 |
+| `pointer.json` | 头部形状、边界 token 与温度 | 770 字节 |
+| tokenizer/config 文件 | 请求编码和模型配置 | 约 17.2 MB |
+`SHA256SUMS.json` 列出推理包文件的大小和 SHA-256。它不包含自身的哈希。发布包未提供 BF16 safetensors 分片，也未包含训练数据、训练日志或原始评论。
+## 推理示例
+推荐使用 pip 包。Windows x64 且 CPU 支持 AVX2 时，bit-jev 0.12.10 wheel 已携带 CPU 与 Vulkan GPU 原生 runner；首次加载会按需下载约 1.19 GB 的模型。使用 `device="cpu"` 或 `device="gpu"` 推理无需 Git、CMake、C++ 编译器或 Vulkan SDK；Vulkan GPU 需要显卡驱动提供 `vulkan-1.dll`。其他系统和 CUDA 后端按需从固定源码构建，需要 Git、CMake 3.28+ 与 C++17 编译器；CUDA 构建还需要 CUDA Toolkit。
 ```python
+from bit_jev.gguf import BitJev
+request = {
+    "state": "客户报告同一订单被重复扣款。",
+    "questions": {
+        "team": {
+            "type": "choice",
+            "instructions": "哪个团队应处理？",
+            "criteria": {"billing": "支付与退款", "shipping": "物流配送"},
+        }
+    },
+}
 with BitJev.from_pretrained(device="cpu", threads=8) as model:
+    result = model.infer(request)
+    print(result["answers"])
+    print(result["latency_ms"])
 ```
+`device="gpu"` 使用 Vulkan；`device="cuda"` 使用 CUDA 构建。`infer()` 复用常驻模型并返回答案、logits、概率和原生推理耗时。完整 CLI、离线目录和构建细节见[GGUF 安装与推理指南](https://github.com/Zeaulo/bit-jev/blob/main/docs/GGUF_PACKAGE.zh-CN.md)。本模型仓库只保存模型文件；两个预编译 runner 位于 PyPI 的 Windows x64 wheel。
+## 性能案例：AutoDL EPYC 9654 CPU 与另一台 RTX 5090
+以下测量来自同一道固定开发题，输入 703 tokens、77 个候选项；原生推理计时不含模型加载。速度图采用 EPYC 9654 容器 32 核配额 / 32 线程 I2_S 新测量与另一台机器的历史 RTX 5090 FP16 混合精度 PyTorch 路径；内存图仍展示原 Xeon Gold 6459C / RTX 5090 同机案例。这组 GPU 数字不是新 pip 包的 GGUF/Vulkan 或 GGUF/CUDA 测试结果。
+| 路径 | 平均推理时间 | 重复次数 | 观测内存 |
 | --- | ---: | ---: | ---: |
+| EPYC 9654，32 核配额 / 32 线程，I2_S | 1,954.46 ms | 6 | 进程峰值 RSS 1,625.88 MiB |
+| Xeon Gold 6459C，8 线程（历史） | 3,127.88 ms | 3 | 进程峰值 RSS 1,622.74 MiB |
+| Xeon Gold 6459C，16 线程（历史） | 1,972.17 ms | 3 | 进程峰值 RSS 1,624.52 MiB |
+| 另一台机器 RTX 5090，FP16 | 86.56 ms | 5 | GPU 峰值分配 4,935.53 MiB |
+![bit-jev AutoDL 单题推理耗时横条对比](bit-jev-case-speed.zh-CN.png)
+![bit-jev AutoDL 峰值占用横条对比](bit-jev-case-memory.zh-CN.png)
+[English charts](bit-jev-case-speed.en.png)
+EPYC 同机 16 线程补充测试均值 3,210.12 ms，32 线程约快 1.64 倍。图中 CPU 与 GPU 路径来自不同机器，且使用不同权重格式和数值精度，因此不能解释为纯硬件加速比。CPU RSS 与 GPU 分配量是不同口径。此单题少量重复只作为案例，不代表通用吞吐或准确率承诺。[EPYC 32 线程逐次数据](https://github.com/Zeaulo/bit-jev/blob/main/docs/benchmark-data/bit-jev-epyc9654-cpu32-2026-09-28.json)与原同机案例 `benchmark_case_autodl.json` 均不含输入文本、候选内容或预测结果。模型不生成答案 token，因此不适用生成 tokens/s 指标。准确率、Brier、NLL 与 ECE 尚无可复核的公开留出集报告，本页不填入推测值。
+## 数据来源与使用边界
+训练数据是本地 `decision-v7` 多源决策集，包含 Yelp 评论记录；教师监督来自 Kev 9B 候选项 logits。仓库不包含 Yelp 原始记录。项目已向 Yelp 发送关于衍生权重和指标发布范围的许可申请，截至 2026-09-28 未收到书面答复。下载者应自行审查适用的 Yelp 数据条款及其对衍生权重的影响。
+本模型**没有单独授予开放权重许可证**。代码仓库的 Apache-2.0、Microsoft 基础模型许可证及 Kev 源码许可证分别适用于各自作品，不能视为对 Yelp 数据或本衍生检查点的许可。此卡记录项目当前公开状态，不构成法律意见。
+## 评测范围与局限
+- 当前公开的 bit-jev 结果只有上表的单题延迟与内存案例；微软原版 BitNet 的基础模型基准是另一组独立测量，不能当成本模型成绩。
+- 没有提供完整训练/测试来源拆分上的 Accuracy、Brier、NLL、ECE 或置信区间。
+- 测试题为开发案例，重复次数少，不能外推到长输入、多问题请求或其他 CPU/GPU。
+- 当前原生 CPU runner 每个问题执行一条因果序列；多问题请求会重复处理共享 state。
+- 选择结果受候选项措辞、顺序、长度与训练分布影响。重要决策需在目标数据上验证并保留人工复核。
+## 引用
 ```bibtex
 @misc{bitjev2026,

README.zh-CN.md CHANGED Viewed

@@ -14,18 +14,18 @@ tags:
 # bit-jev-2b-distilled
-[English model card](README.en.md) · [源码仓库](https://github.com/Zeaulo/bit-jev) · [pip 安装](https://pypi.org/project/bit-jev/)
-![bit-jev 三值输入、推理引擎与候选结果](decision-engine.png)
-首次使用只需安装 pip 包并运行自带示例：
 ```bash
-python -m pip install --upgrade bit-jev
-bit-jev-demo
 ```
-第一次运行会下载约 1.19 GB 模型；后续复用缓存。`bit-jev-demo --device gpu` 选择 Vulkan。示例输出是模型实际推理结果，没有预写的预测。
 ![bit-jev 训练、蒸馏、量化与 CPU/Vulkan 推理流程](project-flow.zh-CN.png)
@@ -72,37 +72,48 @@ I2_S GGUF + float32 指针头
 ## 推理示例
-推荐使用 pip 包。Windows x64 且 CPU 支持 AVX2 时，bit-jev 0.11.10 wheel 已携带 CPU 与 Vulkan GPU 原生 runner；首次加载会按需下载约 1.19 GB 的模型。使用 `device="cpu"` 或 `device="gpu"` 推理无需 Git、CMake、C++ 编译器或 Vulkan SDK；Vulkan GPU 需要显卡驱动提供 `vulkan-1.dll`。其他系统和 CUDA 后端按需从固定源码构建，需要 Git、CMake 3.28+ 与 C++17 编译器；CUDA 构建还需要 CUDA Toolkit。
-```bash
-pip install bit-jev
-```
 ```python
-from bit_jev import BitJev
-request = {"state": "客户报告重复扣款。", "questions": {"team": {"type": "choice", "instructions": "哪个团队处理？", "criteria": {"billing": "支付退款", "shipping": "物流配送"}}}}
 with BitJev.from_pretrained(device="cpu", threads=8) as model:
-    print(model.infer(request)["answers"])
 ```
 `device="gpu"` 使用 Vulkan；`device="cuda"` 使用 CUDA 构建。`infer()` 复用常驻模型并返回答案、logits、概率和原生推理耗时。完整 CLI、离线目录和构建细节见[GGUF 安装与推理指南](https://github.com/Zeaulo/bit-jev/blob/main/docs/GGUF_PACKAGE.zh-CN.md)。本模型仓库只保存模型文件；两个预编译 runner 位于 PyPI 的 Windows x64 wheel。
-## 性能案例：AutoDL Xeon Gold 6459C / RTX 5090
-以下测量来自一道固定开发题，输入 703 tokens、77 个候选项；推理计时不含加载。CPU 使用 I2_S 原生路径，GPU 使用实验性 FP16 混合精度 PyTorch 路径。这组 GPU 数字不是新 pip 包的 GGUF/Vulkan 或 GGUF/CUDA 测试结果。
 | 路径 | 平均推理时间 | 重复次数 | 观测内存 |
 | --- | ---: | ---: | ---: |
-| CPU，8 线程 | 3,127.88 ms | 3 | 进程峰值 RSS 1,622.74 MiB |
-| CPU，16 线程 | 1,972.17 ms | 3 | 进程峰值 RSS 1,624.52 MiB |
-| RTX 5090 | 86.56 ms | 5 | GPU 峰值分配 4,935.53 MiB |
-![bit-jev AutoDL 单题延迟和内存对比](bit-jev-autodl-case.zh-CN.png)
-[English chart](bit-jev-autodl-case.en.png)
-同一道题上，16 线程 CPU 与 RTX 5090 GPU 路径的延迟比约为 22.8。两条路径使用不同权重格式和数值精度，因此该比值不能解释为纯硬件加速比。CPU RSS 与 GPU 分配量是不同口径。此单题少量重复只作为案例，不代表通用吞吐或准确率承诺。详细的脱敏计时数据见 `benchmark_case_autodl.json`；本包没有收录输入文本、候选内容或预测结果。模型不生成答案 token，因此不适用生成 tokens/s 指标。准确率、Brier、NLL 与 ECE 尚无可复核的公开留出集报告，本页不填入推测值。
 ## 数据来源与使用边界

 # bit-jev-2b-distilled
+[English model card](README.en.md) · [源码仓库](https://github.com/Zeaulo/bit-jev) · [pip 安装](https://pypi.org/project/bit-jev/) · [ModelScope 镜像](https://www.modelscope.cn/models/JingHao9616/bit-jev-2b-distilled)
+![bit-jev：二进制轨迹与加速火箭 Logo](bit-jev-logo.png)
+在运行推理的同一个 Python 3.11/3.12 环境中安装并核对版本：
 ```bash
+python -m pip install --upgrade --no-cache-dir bit-jev==0.12.10 -i https://pypi.org/simple
+python -c "from importlib.metadata import version; import bit_jev; print(version('bit-jev'), bit_jev.__file__)"
 ```
+版本应为 `0.12.10`，导入路径应指向当前环境的 `site-packages/bit_jev`。然后直接运行下方的 Python 示例；无需依赖 `bit-jev-demo` 命令的 PATH。首次加载会下载约 1.19 GB 模型，后续复用缓存。默认先尝试 Hugging Face，连接失败时回退 ModelScope；国内网络可在 `from_pretrained()` 中传入 `source="modelscope"`。镜像版本滞后及环境混用的处理见[安装指南](https://github.com/Zeaulo/bit-jev/blob/main/docs/GGUF_PACKAGE.zh-CN.md)。
 ![bit-jev 训练、蒸馏、量化与 CPU/Vulkan 推理流程](project-flow.zh-CN.png)
 ## 推理示例
+推荐使用 pip 包。Windows x64 且 CPU 支持 AVX2 时，bit-jev 0.12.10 wheel 已携带 CPU 与 Vulkan GPU 原生 runner；首次加载会按需下载约 1.19 GB 的模型。使用 `device="cpu"` 或 `device="gpu"` 推理无需 Git、CMake、C++ 编译器或 Vulkan SDK；Vulkan GPU 需要显卡驱动提供 `vulkan-1.dll`。其他系统和 CUDA 后端按需从固定源码构建，需要 Git、CMake 3.28+ 与 C++17 编译器；CUDA 构建还需要 CUDA Toolkit。
 ```python
+from bit_jev.gguf import BitJev
+request = {
+    "state": "客户报告同一订单被重复扣款。",
+    "questions": {
+        "team": {
+            "type": "choice",
+            "instructions": "哪个团队应处理？",
+            "criteria": {"billing": "支付与退款", "shipping": "物流配送"},
+        }
+    },
+}
 with BitJev.from_pretrained(device="cpu", threads=8) as model:
+    result = model.infer(request)
+    print(result["answers"])
+    print(result["latency_ms"])
 ```
 `device="gpu"` 使用 Vulkan；`device="cuda"` 使用 CUDA 构建。`infer()` 复用常驻模型并返回答案、logits、概率和原生推理耗时。完整 CLI、离线目录和构建细节见[GGUF 安装与推理指南](https://github.com/Zeaulo/bit-jev/blob/main/docs/GGUF_PACKAGE.zh-CN.md)。本模型仓库只保存模型文件；两个预编译 runner 位于 PyPI 的 Windows x64 wheel。
+## 性能案例：AutoDL EPYC 9654 CPU 与另一台 RTX 5090
+以下测量来自同一道固定开发题，输入 703 tokens、77 个候选项；原生推理计时不含模型加载。速度图采用 EPYC 9654 容器 32 核配额 / 32 线程 I2_S 新测量与另一台机器的历史 RTX 5090 FP16 混合精度 PyTorch 路径；内存图仍展示原 Xeon Gold 6459C / RTX 5090 同机案例。这组 GPU 数字不是新 pip 包的 GGUF/Vulkan 或 GGUF/CUDA 测试结果。
 | 路径 | 平均推理时间 | 重复次数 | 观测内存 |
 | --- | ---: | ---: | ---: |
+| EPYC 9654，32 核配额 / 32 线程，I2_S | 1,954.46 ms | 6 | 进程峰值 RSS 1,625.88 MiB |
+| Xeon Gold 6459C，8 线程（历史） | 3,127.88 ms | 3 | 进程峰值 RSS 1,622.74 MiB |
+| Xeon Gold 6459C，16 线程（历史） | 1,972.17 ms | 3 | 进程峰值 RSS 1,624.52 MiB |
+| 另一台机器 RTX 5090，FP16 | 86.56 ms | 5 | GPU 峰值分配 4,935.53 MiB |
+![bit-jev AutoDL 单题推理耗时横条对比](bit-jev-case-speed.zh-CN.png)
+![bit-jev AutoDL 峰值占用横条对比](bit-jev-case-memory.zh-CN.png)
+[English charts](bit-jev-case-speed.en.png)
+EPYC 同机 16 线程补充测试均值 3,210.12 ms，32 线程约快 1.64 倍。图中 CPU 与 GPU 路径来自不同机器，且使用不同权重格式和数值精度，因此不能解释为纯硬件加速比。CPU RSS 与 GPU 分配量是不同口径。此单题少量重复只作为案例，不代表通用吞吐或准确率承诺。[EPYC 32 线程逐次数据](https://github.com/Zeaulo/bit-jev/blob/main/docs/benchmark-data/bit-jev-epyc9654-cpu32-2026-09-28.json)与原同机案例 `benchmark_case_autodl.json` 均不含输入文本、候选内容或预测结果。模型不生成答案 token，因此不适用生成 tokens/s 指标。准确率、Brier、NLL 与 ECE 尚无可复核的公开留出集报告，本页不填入推测值。
 ## 数据来源与使用边界

benchmark_case_epyc.json ADDED Viewed

	@@ -0,0 +1,62 @@

+{
+  "format": "bit-jev-epyc9654-cpu32-case-v1",
+  "publication_status": "public_sanitized_case_study",
+  "checkpoint": {
+    "name": "bit-jev-2b-distilled",
+    "cpu_format": "I2_S GGUF with float32 pointer head",
+    "cpu_gguf_sha256": "731700ba3112e35dc9bbecf54fe97b79d91b69246d765413ce683e06250773ff",
+    "head_f32_sha256": "a3b3df8f5d4803d575e64c4f15e8ab09c00762e4140917c07925705ba43c1b27"
+  },
+  "workload": {
+    "questions": 1,
+    "input_tokens": 703,
+    "options": 77,
+    "encoded_input_sha256": "2d2921d9d0e46c1540f71c283b07668ff0fe8ac5d2fa52911588f65d0be4c9c6",
+    "input_contents_included": false
+  },
+  "hardware": {
+    "cpu": "AMD EPYC 9654 96-Core Processor",
+    "platform": "AutoDL Ubuntu 22.04 container, Linux x86_64",
+    "host_logical_cpus_visible_to_lscpu": 192,
+    "container_cpu_quota_cores": 32,
+    "container_cpuset": "64-95",
+    "numa_nodes_visible": 1
+  },
+  "build": {
+    "project_commit": "4272aacc0cabc167077e61df86acaedfab5fd35f",
+    "bitnet_commit": "0b341e582afbf9e1011f24744b554c96a3477eb5",
+    "llama_cpp_commit": "390c307752ab78fd8189f359d6954c9ba1be74af",
+    "cmake": "3.31.10",
+    "compiler": "g++ 11.4.0",
+    "configuration": "Release, GGML_NATIVE=ON, GGML_OPENMP=ON, Vulkan=OFF, CUDA=OFF",
+    "native_binary_sha256": "8f24ada846ab1f30b2b1ae4ac0a35d007747d3a95f5ae1c6cf66b465e5081077"
+  },
+  "timing_protocol": {
+    "native_runner_threads": 32,
+    "batch": 128,
+    "process_launches": 2,
+    "requests_per_launch": 3,
+    "model_loading_included_in_native_latency": false,
+    "explicit_cpu_warmup": false,
+    "same_encoded_request_repeated": true
+  },
+  "measurement": {
+    "path": "native_cpu_i2_s_32_threads",
+    "inference_ms_by_launch": [
+      [1979.920258, 1946.525392, 1949.816113],
+      [1971.828346, 1949.075305, 1929.623975]
+    ],
+    "peak_process_rss_mib_by_launch": [1625.8828125, 1625.7265625]
+  },
+  "diagnostic_16_thread_run": {
+    "inference_ms": [3225.943667, 3196.725099, 3207.690814],
+    "peak_process_rss_mib": 1623.09375
+  },
+  "comparison_boundary": {
+    "historical_gpu_source": "bit-jev-autodl-case-2026-09-27.json",
+    "gpu_hardware": "NVIDIA GeForce RTX 5090 on a different AutoDL host",
+    "gpu_path": "experimental FP16 mixed-precision PyTorch",
+    "note": "The speed figure juxtaposes deployment paths measured on different hosts and weight formats. It is not an isolated CPU-versus-GPU hardware speedup."
+  },
+  "rights_note": "The training set included Yelp review records. The maintainer directed publication of sanitized timing aggregates; no request text, options, prediction, or raw review record is included. No written Yelp response had been received on 2026-09-28."
+}