Update inference code and model card

README.md

@@ -3,45 +3,46 @@ license: apache-2.0
 library_name: pytorch
 pipeline_tag: image-classification
 tags:
-  - handwritten-chinese-character-recognition
-  - casia-hwdb
-  - mobilenet-v2
-  - ncnn
-  - int8
+- handwritten-chinese-character-recognition
+- casia-hwdb
+- mobilenet-v2
+- ncnn
+- int8
 ---
 
 # Handwritten
 
-MobileNetV2 handwritten Chinese character recognizer trained on CASIA HWDB1.1.
-The classifier covers 3,755 GB2312 level-1 Chinese characters with 64×64
-grayscale input.
+MobileNetV2 手写汉字识别模型,覆盖 3755 个 GB2312 一级汉字。输入为 64×64
+灰度图,训练数据来自 CASIA HWDB1.1。
 
-## Results
+## 指标
 
-| Metric | Value |
+| 指标 | 数值 |
 |---|---:|
 | PyTorch top-1 | 95.47% |
 | PyTorch top-10 | 99.58% |
-| Best epoch | 27 |
-| NCNN INT8 size | 4.1 MB |
+| NCNN INT8 权重 | 4.1 MB |
+| 预估移动端延迟 | 2–5 ms |
 
-## Files
+## 直接使用 NCNN
 
-- `best.pt`: PyTorch model state, training configuration, epoch, and top-1 score.
-- `ncnn/`: ready-to-run NCNN INT8 model and output charset.
+```bash
+pip install numpy Pillow ncnn
+python example.py path/to/image.png
+```
 
-The checkpoint SHA-256 is
-`151f32b03c49dbed77f3b8076035d28ce050d70a1a102e12581274a44cb10460`.
+```python
+from inference import HCCRRecognizer
 
-## Load the checkpoint
+model = HCCRRecognizer.from_pretrained(".")
+print(model.predict_file("path/to/image.png", k=10))
+```
 
-Clone the source repository and place this checkpoint at
-`runs/mbv2_phase1_aug/best.pt`:
+## 加载 PyTorch checkpoint
 
 ```python
 import torch
-
-from src.models import build_model
+from model import build_model
 
 checkpoint = torch.load("best.pt", map_location="cpu", weights_only=False)
 model = build_model(checkpoint["cfg"]["model"], num_classes=3755)
@@ -49,10 +50,21 @@ model.load_state_dict(checkpoint["model"])
 model.eval()
 ```
 
-Source and full training/deployment instructions:
-https://github.com/Ismantic/Handwritten
+## 文件
+
+| 文件 | 内容 |
+|---|---|
+| `best.pt` | PyTorch checkpoint、训练配置、epoch 和 top-1 |
+| `model.py` | PyTorch 模型定义 |
+| `inference.py` | 自包含 NCNN 推理入口 |
+| `normalize.py` | 与训练一致的图像归一化 |
+| `example.py` | 单图命令行示例 |
+| `ncnn/model.ncnn.*` | NCNN INT8 网络和权重 |
+| `ncnn/charset.json` | 输出索引到汉字的映射 |
+| `release_metadata.json` | 发布来源、指标和文件校验值 |
+
+完整训练、导出与 Android 部署见 [https://github.com/Ismantic/Handwritten](https://github.com/Ismantic/Handwritten)。
 
-## Data
+## 数据许可
 
-CASIA HWDB1.1 is not redistributed in this repository. Obtain it through the
-official CASIA channel and comply with its license.
+本仓库不再分发 CASIA HWDB1.1。请从官方渠道申请数据并遵守其许可。

example.py

@@ -0,0 +1,22 @@
+"""用发布包识别一张白底黑字图片。"""
+
+import argparse
+from pathlib import Path
+
+from inference import HCCRRecognizer
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("image", type=Path)
+    parser.add_argument("--model-dir", type=Path, default=Path("."))
+    parser.add_argument("-k", type=int, default=10)
+    args = parser.parse_args()
+
+    model = HCCRRecognizer.from_pretrained(args.model_dir)
+    for char, probability in model.predict_file(args.image, k=args.k):
+        print(f"{char}\t{probability:.2%}")
+
+
+if __name__ == "__main__":
+    main()

inference.py

@@ -0,0 +1,64 @@
+"""随 HF 模型发布的自包含 NCNN 推理入口。"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import ncnn
+import numpy as np
+from PIL import Image
+
+from normalize import normalize
+
+
+class HCCRRecognizer:
+    def __init__(
+        self,
+        param_path: str | Path,
+        bin_path: str | Path,
+        charset_path: str | Path,
+        num_threads: int = 4,
+    ) -> None:
+        self.net = ncnn.Net()
+        self.net.opt.use_vulkan_compute = False
+        self.net.opt.num_threads = num_threads
+        self.net.load_param(str(param_path))
+        self.net.load_model(str(bin_path))
+        data = json.loads(Path(charset_path).read_text(encoding="utf-8"))
+        self.idx_to_char = {int(i): ch for ch, i in data["char_to_idx"].items()}
+
+    @classmethod
+    def from_pretrained(cls, model_dir: str | Path = ".", num_threads: int = 4):
+        root = Path(model_dir)
+        return cls(
+            root / "ncnn/model.ncnn.param",
+            root / "ncnn/model.ncnn.bin",
+            root / "ncnn/charset.json",
+            num_threads=num_threads,
+        )
+
+    @staticmethod
+    def preprocess(image: Image.Image) -> np.ndarray:
+        gray = np.asarray(image.convert("L"), dtype=np.uint8)
+        normalized = normalize(gray)
+        return ((255 - normalized).astype(np.float32) / 255.0)[None, :, :]
+
+    def predict(self, image: Image.Image, k: int = 10) -> list[tuple[str, float]]:
+        x = self.preprocess(image)
+        if not x.any():
+            return []
+        extractor = self.net.create_extractor()
+        extractor.input("in0", ncnn.Mat(x))
+        ret, out = extractor.extract("out0")
+        if ret != 0:
+            raise RuntimeError(f"ncnn extract failed: {ret}")
+        logits = np.asarray(out)
+        probs = np.exp(logits - logits.max())
+        probs /= probs.sum()
+        indices = np.argsort(-probs)[:k]
+        return [(self.idx_to_char[int(i)], float(probs[i])) for i in indices]
+
+    def predict_file(self, path: str | Path, k: int = 10) -> list[tuple[str, float]]:
+        with Image.open(path) as image:
+            return self.predict(image, k=k)

model.py

@@ -0,0 +1,340 @@
+"""HCCR 模型定义。
+
+baseline:plain CNN(5 个 conv block + GAP + Linear)。
+- 输入:  [B, 1, 64, 64]
+- 输出:  [B, num_classes] (logits)
+- 参数量:约 1.1M(num_classes=3755)
+- 不用 dropout(BN 已经有正则效果);如需可在 classifier 前加
+
+约束:
+- 只用标准算子(Conv2d / BN / ReLU / MaxPool / Linear)便于后续导出
+- 固定输入 shape(避免动态控制流)
+"""
+
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+
+
+def _conv_bn_relu(in_ch: int, out_ch: int, kernel_size: int = 3, padding: int = 1) -> nn.Sequential:
+    return nn.Sequential(
+        nn.Conv2d(in_ch, out_ch, kernel_size, padding=padding, bias=False),
+        nn.BatchNorm2d(out_ch),
+        nn.ReLU(inplace=True),
+    )
+
+
+class GWAP(nn.Module):
+    """Global Weighted Average Pooling(Melnyk et al. 2020)。
+
+    学一个空间权重图代替朴素 GAP:
+        out[c] = sum_{i,j} W[c, i, j] * x[c, i, j]
+    初始化为 1/(H*W) 即等价 GAP,有梯度后偏离学到"哪些位置更重要"。
+
+    可学参数:C × H × W(对 448 ch / 4×4 spatial 是 7168,可忽略)。
+    """
+
+    def __init__(self, channels: int, spatial_h: int, spatial_w: int) -> None:
+        super().__init__()
+        init_val = 1.0 / (spatial_h * spatial_w)
+        self.weight = nn.Parameter(
+            torch.full((channels, spatial_h, spatial_w), init_val, dtype=torch.float32)
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # x: [B, C, H, W] → [B, C]
+        return (x * self.weight).sum(dim=(2, 3))
+
+
+class PlainCNN(nn.Module):
+    """5 stage CNN,每 stage 后 MaxPool 下采样一次。
+
+    [1,64,64] → 32 → 32(/2)=32 → 64(/2)=16 → 96(/2)=8 → 128(/2)=4 → 192(/2)=2 → GAP → Linear
+    """
+
+    def __init__(self, num_classes: int, in_channels: int = 1) -> None:
+        super().__init__()
+        self.features = nn.Sequential(
+            _conv_bn_relu(in_channels, 32),
+            nn.MaxPool2d(2),  # 64→32
+            _conv_bn_relu(32, 64),
+            nn.MaxPool2d(2),  # 32→16
+            _conv_bn_relu(64, 96),
+            nn.MaxPool2d(2),  # 16→8
+            _conv_bn_relu(96, 128),
+            nn.MaxPool2d(2),  # 8→4
+            _conv_bn_relu(128, 192),
+            nn.MaxPool2d(2),  # 4→2
+        )
+        self.gap = nn.AdaptiveAvgPool2d(1)
+        self.classifier = nn.Linear(192, num_classes)
+
+        self._init_weights()
+
+    def _init_weights(self) -> None:
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.ones_(m.weight)
+                nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                nn.init.zeros_(m.bias)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.features(x)
+        x = self.gap(x).flatten(1)
+        return self.classifier(x)
+
+
+class MelnykNet(nn.Module):
+    """Melnyk-Net(2020 Soft Computing,Melnyk/You/Li)。
+
+    原版 96×96 输入,这里改造为 64×64(我们的部署口径)。
+    14 conv(3×3 + BN + ReLU)分 5 stage,4 次 avg pool,GWAP,FC。
+
+    spatial 流动:64 → 32 → 16 → 8 → 4
+    通道流动(注意"瓶颈"模式 high-low-high):
+        stage 1: 64, 64                        @ 64×64
+        stage 2: 96, 64, 96                    @ 32×32
+        stage 3: 128, 96, 128                  @ 16×16
+        stage 4: 256, 192, 256                 @ 8×8
+        stage 5: 448, 256, 448                 @ 4×4
+
+    总参数 ~6.5M(同原版),FP32 ~25 MB,INT8 ~6.5 MB(超 plan 5MB,需要后续考虑)。
+    """
+
+    def __init__(self, num_classes: int, in_channels: int = 1) -> None:
+        super().__init__()
+
+        def block(in_ch: int, out_ch: int) -> nn.Sequential:
+            return _conv_bn_relu(in_ch, out_ch)
+
+        self.stage1 = nn.Sequential(block(in_channels, 64), block(64, 64))
+        self.stage2 = nn.Sequential(block(64, 96), block(96, 64), block(64, 96))
+        self.stage3 = nn.Sequential(block(96, 128), block(128, 96), block(96, 128))
+        self.stage4 = nn.Sequential(block(128, 256), block(256, 192), block(192, 256))
+        self.stage5 = nn.Sequential(block(256, 448), block(448, 256), block(256, 448))
+        self.pool = nn.AvgPool2d(2)
+        self.gwap = GWAP(448, 4, 4)
+        self.classifier = nn.Linear(448, num_classes)
+
+        self._init_weights()
+
+    def _init_weights(self) -> None:
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.ones_(m.weight)
+                nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                nn.init.zeros_(m.bias)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.stage1(x); x = self.pool(x)
+        x = self.stage2(x); x = self.pool(x)
+        x = self.stage3(x); x = self.pool(x)
+        x = self.stage4(x); x = self.pool(x)
+        x = self.stage5(x)  # 4×4
+        x = self.gwap(x)
+        return self.classifier(x)
+
+
+def _build_mobilenet_v3_small_hccr(num_classes: int, in_channels: int = 1) -> nn.Module:
+    """torchvision MobileNetV3-Small 改造:
+    - 第一层 conv 改成单通道输入(3 → 1)
+    - 分类头去掉 576 → 1024 隐层,直接 576 → num_classes(省 ~600K params,3755 类下分类头本身就是大头)
+    - 保留 HSwish / SE 块 / depthwise conv,PNNX/NCNN 都原生支持
+
+    输入: [B, 1, 64, 64]   spatial 走 stride 2×5 → 64 → 32 → 16 → 8 → 4 → 2
+    输出: [B, num_classes]
+    """
+    from torchvision.models import mobilenet_v3_small
+
+    model = mobilenet_v3_small(num_classes=num_classes)
+    model.features[0][0] = nn.Conv2d(
+        in_channels, 16, kernel_size=3, stride=2, padding=1, bias=False
+    )
+    model.classifier = nn.Sequential(
+        nn.Dropout(p=0.2, inplace=False),
+        nn.Linear(576, num_classes),
+    )
+    # torchvision 在 mobilenet_v3_small() 构造时跑过 init loop(Conv kaiming_normal,
+    # Linear normal(0, 0.01))。我们之后才替换层,新层是 PyTorch 默认 init,
+    # stddev 偏大(分类头 2.3x),早期梯度信号偏强 —— 重新走一遍同样的 init。
+    for layer in (model.features[0][0], model.classifier[1]):
+        if isinstance(layer, nn.Conv2d):
+            nn.init.kaiming_normal_(layer.weight, mode="fan_out")
+            if layer.bias is not None:
+                nn.init.zeros_(layer.bias)
+        elif isinstance(layer, nn.Linear):
+            nn.init.normal_(layer.weight, 0, 0.01)
+            nn.init.zeros_(layer.bias)
+    return model
+
+
+class MobileNetV2WithGWAP(nn.Module):
+    """V2 改造 + 借 Melnyk-Net 的 GWAP 替换 GAP。
+
+    流程:V2 features → GWAP(C × 2 × 2 学习权重)→ Dropout → Linear。
+    输入 [B,1,64,64]:V2 5 次 stride 2 下采样 → 2×2 spatial。
+    """
+
+    def __init__(
+        self, num_classes: int, in_channels: int = 1, last_channel: int = 576
+    ) -> None:
+        super().__init__()
+        from torchvision.models import mobilenet_v2
+
+        base = mobilenet_v2()
+        base.features[0][0] = nn.Conv2d(
+            in_channels, 32, kernel_size=3, stride=2, padding=1, bias=False
+        )
+        base.features[18] = nn.Sequential(
+            nn.Conv2d(320, last_channel, kernel_size=1, bias=False),
+            nn.BatchNorm2d(last_channel),
+            nn.ReLU6(inplace=True),
+        )
+        self.features = base.features
+        # 64 input → 5 次 stride 2 → 2×2 spatial 在末端
+        self.gwap = GWAP(last_channel, 2, 2)
+        self.classifier = nn.Sequential(
+            nn.Dropout(p=0.2, inplace=False),
+            nn.Linear(last_channel, num_classes),
+        )
+
+        for layer in (
+            self.features[0][0],
+            self.features[18][0],
+            self.features[18][1],
+            self.classifier[1],
+        ):
+            if isinstance(layer, nn.Conv2d):
+                nn.init.kaiming_normal_(layer.weight, mode="fan_out")
+                if layer.bias is not None:
+                    nn.init.zeros_(layer.bias)
+            elif isinstance(layer, nn.BatchNorm2d):
+                nn.init.ones_(layer.weight)
+                nn.init.zeros_(layer.bias)
+            elif isinstance(layer, nn.Linear):
+                nn.init.normal_(layer.weight, 0, 0.01)
+                nn.init.zeros_(layer.bias)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.features(x)  # [B, last_ch, 2, 2]
+        x = self.gwap(x)      # [B, last_ch]
+        return self.classifier(x)
+
+
+def _replace_relu6_with_relu(module: nn.Module) -> None:
+    """递归把 ReLU6 替换为 ReLU。
+
+    用途:MobileNetV2 默认 ReLU6 在 INT8 量化时(activation 被 clip 到 [0, 6]
+    + 1×1 expand 高动态范围 + DW 各通道差异大)精度损失大。换成 ReLU 后
+    激活分布更线性,PTQ 友好,文献和实测都验证过。
+
+    FP32 精度通常基本不变(< 0.3 点),换来 INT8 PTQ 损失从 2-3 点 → < 1 点。
+    """
+    for name, child in module.named_children():
+        if isinstance(child, nn.ReLU6):
+            setattr(module, name, nn.ReLU(inplace=child.inplace))
+        else:
+            _replace_relu6_with_relu(child)
+
+
+def _build_mobilenet_v2_relu_hccr(
+    num_classes: int, in_channels: int = 1, last_channel: int = 576
+) -> nn.Module:
+    """V2-HCCR + ReLU(替换全部 ReLU6),量化友好版。"""
+    model = _build_mobilenet_v2_hccr(num_classes, in_channels, last_channel)
+    _replace_relu6_with_relu(model)
+    return model
+
+
+def _build_mobilenet_v2_hccr(
+    num_classes: int, in_channels: int = 1, last_channel: int = 576
+) -> nn.Module:
+    """torchvision MobileNetV2 改造 for HCCR:
+    - 第一层 conv 改单通道��入(3 → 1)
+    - 最后 1×1 expand 从 320→1280 改为 320→last_channel(默认 576),
+      避免分类头 Linear(1280, 3755) 单层就 4.8M params
+    - 分类头 Linear(last_channel, num_classes)
+
+    保留 ReLU6 + 标准 inverted residual(无 SE,无 HSwish,无 NAS 不规则宽度),
+    量化最稳。skip connection(ResNet 思想)在 inverted residual 块内自动包含。
+
+    输入: [B, 1, 64, 64]
+    输出: [B, num_classes]
+    """
+    from torchvision.models import mobilenet_v2
+
+    model = mobilenet_v2(num_classes=num_classes)
+    # 1. 第一层 conv:3 → 1
+    model.features[0][0] = nn.Conv2d(
+        in_channels, 32, kernel_size=3, stride=2, padding=1, bias=False
+    )
+    # 2. 最后 1×1 expand:320 → last_channel
+    model.features[18] = nn.Sequential(
+        nn.Conv2d(320, last_channel, kernel_size=1, bias=False),
+        nn.BatchNorm2d(last_channel),
+        nn.ReLU6(inplace=True),
+    )
+    # 3. 分类头:Dropout + Linear
+    model.classifier = nn.Sequential(
+        nn.Dropout(p=0.2, inplace=False),
+        nn.Linear(last_channel, num_classes),
+    )
+    # 4. 替换层后重新跑 torchvision 的 init 约定(同 V3 处理)
+    for layer in (
+        model.features[0][0],
+        model.features[18][0],
+        model.features[18][1],
+        model.classifier[1],
+    ):
+        if isinstance(layer, nn.Conv2d):
+            nn.init.kaiming_normal_(layer.weight, mode="fan_out")
+            if layer.bias is not None:
+                nn.init.zeros_(layer.bias)
+        elif isinstance(layer, nn.BatchNorm2d):
+            nn.init.ones_(layer.weight)
+            nn.init.zeros_(layer.bias)
+        elif isinstance(layer, nn.Linear):
+            nn.init.normal_(layer.weight, 0, 0.01)
+            nn.init.zeros_(layer.bias)
+    return model
+
+
+def build_model(name: str, num_classes: int) -> nn.Module:
+    if name == "plain_cnn":
+        return PlainCNN(num_classes)
+    if name == "mobilenet_v3_small":
+        return _build_mobilenet_v3_small_hccr(num_classes)
+    if name == "mobilenet_v2":
+        return _build_mobilenet_v2_hccr(num_classes)
+    if name == "mobilenet_v2_relu":
+        return _build_mobilenet_v2_relu_hccr(num_classes)
+    if name == "mobilenet_v2_gwap":
+        return MobileNetV2WithGWAP(num_classes)
+    if name == "melnyk_net":
+        return MelnykNet(num_classes)
+    raise ValueError(f"未知模型: {name}")
+
+
+def count_params(model: nn.Module) -> int:
+    return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+
+if __name__ == "__main__":
+    # smoke:确认能 forward,参数量符合预期
+    x = torch.randn(2, 1, 64, 64)
+    for name in ("plain_cnn", "mobilenet_v3_small", "mobilenet_v2", "mobilenet_v2_relu", "mobilenet_v2_gwap", "melnyk_net"):
+        model = build_model(name, num_classes=3755)
+        n = count_params(model)
+        bytes_ = sum(p.numel() * p.element_size() for p in model.parameters())
+        y = model(x)
+        print(f"{name}: {n:,} params ({n/1e6:.2f}M)  fp32={bytes_/1e6:.2f}MB  "
+              f"int8≈{bytes_/4/1e6:.2f}MB  out={tuple(y.shape)}")

normalize.py

@@ -0,0 +1,67 @@
+"""位图 → 64×64 归一化。
+
+输入:HWDB GNT 原始灰度位图(uint8,255=白底,0=黑笔画,任意宽高)
+输出:归一化的 64×64 uint8 灰度图,**保持原始规约**(255=白底,0=黑笔画)
+
+为什么保持白底黑字:推理时手机端把用户笔迹渲染成"白纸黑笔"喂模型,训练数据
+和推理输入分布对齐;若要反转让前景=高值(MNIST 风格),在 dataloader 用
+`255 - x` 即可。
+
+流程:
+  1. 阈值化找笔画像素的最小外接矩形(笔画 = 像素值低)
+  2. 等比缩放,长边对齐到 56 像素
+  3. 居中放到 64×64 画布(白底,周围 4 像素白边距)
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from PIL import Image
+
+
+CANVAS_SIZE = 64
+CONTENT_SIZE = 56
+MARGIN = (CANVAS_SIZE - CONTENT_SIZE) // 2  # 4
+FG_THRESHOLD = 220  # 像素 < 阈值算前景(笔画);GNT 背景 ≈ 255,笔画值偏低
+
+
+def normalize(bitmap: np.ndarray) -> np.ndarray:
+    """归一化到 64×64 uint8,白底黑字(255=白,0=黑)。"""
+    if bitmap.ndim != 2:
+        raise ValueError(f"期望 2D 位图,得到 shape={bitmap.shape}")
+
+    # 1. 找前景(笔画)外接矩形
+    fg = bitmap < FG_THRESHOLD
+    if not fg.any():
+        # 全白(空样本),返回纯白画布
+        return np.full((CANVAS_SIZE, CANVAS_SIZE), 255, dtype=np.uint8)
+    ys, xs = np.where(fg)
+    y0, y1 = ys.min(), ys.max() + 1
+    x0, x1 = xs.min(), xs.max() + 1
+    cropped = bitmap[y0:y1, x0:x1]
+
+    # 2. 等比缩放,长边对齐到 CONTENT_SIZE
+    h, w = cropped.shape
+    scale = CONTENT_SIZE / max(h, w)
+    new_h = max(1, int(round(h * scale)))
+    new_w = max(1, int(round(w * scale)))
+    pil = Image.fromarray(cropped, mode="L")
+    pil = pil.resize((new_w, new_h), Image.BILINEAR)
+    resized = np.asarray(pil, dtype=np.uint8)
+
+    # 3. 居中放到 64×64 画布,白底
+    canvas = np.full((CANVAS_SIZE, CANVAS_SIZE), 255, dtype=np.uint8)
+    off_y = (CANVAS_SIZE - new_h) // 2
+    off_x = (CANVAS_SIZE - new_w) // 2
+    canvas[off_y:off_y + new_h, off_x:off_x + new_w] = resized
+    return canvas
+
+
+if __name__ == "__main__":
+    # 自测:造一个 80×100 的白底图,中间一块黑笔画,跑归一化
+    src = np.full((100, 80), 255, dtype=np.uint8)
+    src[20:80, 15:65] = 50  # 一块笔画(低值)
+    out = normalize(src)
+    print(f"input shape: {src.shape}, output shape: {out.shape}")
+    print(f"output range: [{out.min()}, {out.max()}]")
+    print(f"前景像素数(< {FG_THRESHOLD}): {(out < FG_THRESHOLD).sum()}")

release_metadata.json

@@ -0,0 +1,19 @@
+{
+  "name": "Handwritten",
+  "source_checkpoint": "runs/mbv2_phase1_aug/best.pt",
+  "source_ncnn_param": "save/output/mbv2_aug.int8.ncnn.param",
+  "source_ncnn_bin": "save/output/mbv2_aug.int8.ncnn.bin",
+  "source_charset": "data/processed/charset.json",
+  "model": "mobilenet_v2",
+  "classes": 3755,
+  "metrics": {
+    "top1": 0.9547,
+    "top10": 0.9958
+  },
+  "sha256": {
+    "best.pt": "151f32b03c49dbed77f3b8076035d28ce050d70a1a102e12581274a44cb10460",
+    "ncnn/model.ncnn.param": "8c4d0e594d8a4644fb97411d2b6335f55fed2e1b37057bc88fced724295902a3",
+    "ncnn/model.ncnn.bin": "86a4802e3c8b2ddf1180f3de361546517d708674381e58b3d10b766dc8fba49e",
+    "ncnn/charset.json": "31f5700027c8692122cec5281d12c6382506b36d56075331cd73718f624d4ed2"
+  }
+}