Delete files docs/TRAINING.md docs/INFERENCE.md docs/EVALUATION.md with huggingface_hub

docs/EVALUATION.md

@@ -1,127 +0,0 @@
-# 评估方法 / Evaluation
-
----
-
-## 中文
-
-本文档说明 **87.6% 登录命中率** 是如何测量的，保证结果可复现、可信。
-
-### 核心原则
-
-南+ 验证码没有公开的 ground truth 数据集，因此使用**真实论坛登录**作为唯一、100% 可靠的判定标准：
-
-> **论坛返回"登录成功" = 模型识别正确**
-> **论坛返回"认证码不正确或已过期" = 模型识别错误**
-
-每次判定都是干净的二元结果，不依赖任何主观估计。
-
-### 测试流程（逐次尝试）
-
-1. **抓取登录页** → 解析表单与验证码 URL（带会话 cookie）
-2. **抓取验证码图片**（带时间戳防缓存，150x60 PNG）
-3. **模型推理** → 输出 4 位数字
-4. **提交登录**（带会话 cookie + 表单隐藏字段 + 识别结果）
-5. **读论坛响应** → 成功 / "认证码不正确"
-6. **清空本地会话** → 下一次以全新游客身份开始
-
-保证：
-- 每张验证码绑定独立会话，识别与提交严格一一对应，无会话错位
-- 失败响应用 `SP_DEBUG_LOGIN` 落盘逐条核对，确认为真实"认证码不正确"，而非网络/风控
-- 网络层干扰不计入统计
-
-### 测试环境
-
-| 项 | 值 |
-|---|---|
-| 站点 | south-plus.net |
-| 网络 | 家庭 IP + Cloudflare IP 钉定（绕过 DNS 污染） |
-| 请求间隔 | 7 秒（尊重论坛限流） |
-| 账号 | 真实有效账号 |
-| 模型 | captcha_1000_raw.onnx (88.6% val) |
-
-### 结果
-
-**100 次登录（最终正式测试）**
-
-| 结果 | 次数 |
-|---|---|
-| 登录成功 | **85** |
-| 认证码不正确 | 12 |
-| 被论坛风控拦截（不计入） | 3 |
-| 合计有效 | **97** |
-
-**单次命中率 = 85/97 = 87.6%**
-
-早期小样本：15 次测试 13/15 = 86.7%（供参考）。
-
-**重试收益**：`P(6次内至少成功1次) = 1 - (1 - 0.876)^6 ≈ 99.9997%`，即平均 1 万次登录中约 3 次会在 6 次重试内全部失败。
-
-### 置信度
-
-- 100 次大样本 + 每次二元硬判定 → 统计置信度高
-- 与 15 次小样本（86.7%）高度一致 → 结果稳定
-- 留出验证集（79 张）88.6% 与登录命中 87.6% 接近 → 交叉印证
-
----
-
-## English
-
-This document explains how the **87.6% login success rate** was measured, so the result is reproducible and trustworthy.
-
-### Core principle
-
-There is no public ground-truth dataset for this captcha, so we use **real forum logins** as the sole, 100%-reliable judge:
-
-> **"Login success" from the forum = the model was correct**
-> **"Code incorrect or expired" = the model was wrong**
-
-Every attempt is a clean binary verdict — no subjective estimation.
-
-### Test flow (per attempt)
-
-1. Fetch the login page → parse the form and captcha URL (with session cookie)
-2. Fetch the captcha image (timestamp-cache-busted, 150x60 PNG)
-3. Model inference → 4 digits
-4. Submit login (session cookie + hidden form fields + the code)
-5. Read the forum response → success / "code incorrect"
-6. Clear the local session → next attempt starts as a fresh guest
-
-Guarantees:
-- Each captcha is bound to its own session; recognition and submission are 1:1, no session mismatch
-- Failed responses are dumped via `SP_DEBUG_LOGIN` and checked one by one to confirm genuine "code incorrect", not network/rate-limit pages
-- Network-level interference is excluded from statistics
-
-### Test environment
-
-| Item | Value |
-|---|---|
-| Site | south-plus.net |
-| Network | home IP + Cloudflare IP pinning (bypasses DNS poisoning) |
-| Request interval | 7 seconds (respecting forum rate limits) |
-| Account | a real, valid account |
-| Model | captcha_1000_raw.onnx (88.6% val) |
-
-### Results
-
-**100 logins (final formal test)**
-
-| Result | Count |
-|---|---|
-| Login success | **85** |
-| Code incorrect | 12 |
-| Rate-limited (excluded) | 3 |
-| Valid total | **97** |
-
-**Per-attempt success = 85/97 = 87.6%**
-
-Early small sample: 13/15 = 86.7% (for reference).
-
-**With retries**: `P(success within 6 tries) = 1 - (1 - 0.876)^6 ≈ 99.9997%` — about 3 in 10,000 logins fail after 6 retries.
-
-### Confidence
-
-- 100-attempt sample with hard binary verdicts → high statistical confidence
-- Consistent with the 15-attempt sample (86.7%) → stable result
-- Held-out validation set (79 images) at 88.6% cross-confirms the login figure (87.6%)
-
----

docs/INFERENCE.md

@@ -1,253 +0,0 @@
-# 推理指南 / Inference Guide
-
----
-
-## 中文
-
-### 规格速览
-
-| 项 | 值 |
-|---|---|
-| 输入名 | `input` |
-| 输入形状 | `[batch, 3, 64, 160]` |
-| 输入类型 | float32, 值域 [0,1] (RGB) |
-| 输出名 | `logits` |
-| 输出形状 | `[batch, 4, 10]` |
-| 解码 | 每位置 argmax → 数字 |
-| ONNX opset | 18 |
-
-预处理只有 3 步，无其他：RGB → 缩放到 160x64（双线性）→ 除以 255。
-不做灰度、不去噪、不做均值方差归一化。
-
-### Python
-
-```bash
-pip install onnxruntime pillow numpy
-```
-
-```python
-import numpy as np
-import onnxruntime as ort
-from PIL import Image
-
-_SESSION = None
-
-def get_session(model_path="model.onnx"):
-    global _SESSION
-    if _SESSION is None:
-        _SESSION = ort.InferenceSession(model_path, providers=["CPUExecutionProvider"])
-    return _SESSION
-
-def solve_captcha(img_bytes_or_path, model_path="model.onnx"):
-    sess = get_session(model_path)
-    im = Image.open(img_bytes_or_path).convert("RGB").resize((160, 64), Image.BILINEAR)
-    x = np.asarray(im, dtype=np.float32) / 255.0
-    x = x.transpose(2, 0, 1)[None]          # (1,3,64,160)
-    logits = sess.run(None, {"input": x})[0] # (1,4,10)
-    return "".join(str(int(logits[0, p].argmax())) for p in range(4))
-
-code = solve_captcha("captcha.png")   # "4821"
-```
-
-### Go (onnxruntime_go)
-
-依赖：`github.com/yalue/onnxruntime_go` + onnxruntime 共享库（.dylib/.so）。
-
-```go
-package main
-
-import (
-    "bytes"
-    "fmt"
-    "image"
-    _ "image/png"
-
-    "golang.org/x/image/draw"
-    ort "github.com/yalue/onnxruntime_go"
-)
-
-const (
-    inW, inH = 160, 64
-    nDigits  = 4
-)
-
-type Solver struct {
-    sess *ort.Session[float32]
-    in   *ort.Tensor[float32]
-    out  *ort.Tensor[float32]
-}
-
-func NewSolver(modelPath, libPath string) (*Solver, error) {
-    if libPath != "" { ort.SetSharedLibraryPath(libPath) }
-    if err := ort.InitializeEnvironment(); err != nil { return nil, err }
-    in, err := ort.NewEmptyTensor[float32](ort.NewShape(1, 3, inH, inW))
-    if err != nil { return nil, err }
-    out, err := ort.NewEmptyTensor[float32](ort.NewShape(1, nDigits, 10))
-    if err != nil { in.Destroy(); return nil, err }
-    sess, err := ort.NewSession[float32](modelPath,
-        []string{"input"}, []string{"logits"},
-        []*ort.Tensor[float32]{in}, []*ort.Tensor[float32]{out})
-    if err != nil { in.Destroy(); out.Destroy(); return nil, err }
-    return &Solver{sess, in, out}, nil
-}
-
-func (s *Solver) Solve(png []byte) (string, error) {
-    src, _, err := image.Decode(bytes.NewReader(png))
-    if err != nil { return "", err }
-    dst := image.NewRGBA(image.Rect(0, 0, inW, inH))
-    draw.ApproxBiLinear.Scale(dst, dst.Bounds(), src, src.Bounds(), draw.Over, nil)
-
-    data := s.in.GetData()
-    idx := 0
-    // 模型输入为 NCHW：先写全部 R，再 G，再 B
-    for y := 0; y < inH; y++ { for x := 0; x < inW; x++ { r,_,_,_ := dst.At(x,y).RGBA(); data[idx]=float32(r>>8)/255; idx++ } }
-    for y := 0; y < inH; y++ { for x := 0; x < inW; x++ { _,g,_,_ := dst.At(x,y).RGBA(); data[idx]=float32(g>>8)/255; idx++ } }
-    for y := 0; y < inH; y++ { for x := 0; x < inW; x++ { _,_,b,_ := dst.At(x,y).RGBA(); data[idx]=float32(b>>8)/255; idx++ } }
-
-    if err := s.sess.Run(); err != nil { return "", err }
-    got := s.out.GetData()
-    code := make([]byte, nDigits)
-    for p := 0; p < nDigits; p++ {
-        best := 0
-        for c := 1; c < 10; c++ { if got[p*10+c] > got[p*10+best] { best = c } }
-        code[p] = '0' + byte(best)
-    }
-    return string(code), nil
-}
-```
-
-> 注意：`onnxruntime_go.NewSession` 从文件读模型。若用 `go:embed` 内嵌模型，
-> 改用 `NewSessionWithONNXData` 传字节。
-
-### 性能
-
-- 单张推理：约 5-15ms（CPU，M1/现代 x86）
-- 全流程（加载+预处理+推理）：约 10-30ms
-- 无 GPU 依赖，内存占用 < 50MB
-
----
-
-## English
-
-### Specification
-
-| Item | Value |
-|---|---|
-| Input name | `input` |
-| Input shape | `[batch, 3, 64, 160]` |
-| Input type | float32, range [0,1] (RGB) |
-| Output name | `logits` |
-| Output shape | `[batch, 4, 10]` |
-| Decode | argmax per position → digit |
-| ONNX opset | 18 |
-
-Preprocessing is only three steps: RGB → resize to 160x64 (bilinear) → divide by 255.
-No grayscale, no denoising, no mean/std normalization.
-
-### Python
-
-```bash
-pip install onnxruntime pillow numpy
-```
-
-```python
-import numpy as np
-import onnxruntime as ort
-from PIL import Image
-
-_SESSION = None
-
-def get_session(model_path="model.onnx"):
-    global _SESSION
-    if _SESSION is None:
-        _SESSION = ort.InferenceSession(model_path, providers=["CPUExecutionProvider"])
-    return _SESSION
-
-def solve_captcha(img_bytes_or_path, model_path="model.onnx"):
-    sess = get_session(model_path)
-    im = Image.open(img_bytes_or_path).convert("RGB").resize((160, 64), Image.BILINEAR)
-    x = np.asarray(im, dtype=np.float32) / 255.0
-    x = x.transpose(2, 0, 1)[None]          # (1,3,64,160)
-    logits = sess.run(None, {"input": x})[0] # (1,4,10)
-    return "".join(str(int(logits[0, p].argmax())) for p in range(4))
-
-code = solve_captcha("captcha.png")   # "4821"
-```
-
-### Go (onnxruntime_go)
-
-Deps: `github.com/yalue/onnxruntime_go` + the onnxruntime shared library (.dylib/.so).
-
-```go
-package main
-
-import (
-    "bytes"
-    "fmt"
-    "image"
-    _ "image/png"
-
-    "golang.org/x/image/draw"
-    ort "github.com/yalue/onnxruntime_go"
-)
-
-const (
-    inW, inH = 160, 64
-    nDigits  = 4
-)
-
-type Solver struct {
-    sess *ort.Session[float32]
-    in   *ort.Tensor[float32]
-    out  *ort.Tensor[float32]
-}
-
-func NewSolver(modelPath, libPath string) (*Solver, error) {
-    if libPath != "" { ort.SetSharedLibraryPath(libPath) }
-    if err := ort.InitializeEnvironment(); err != nil { return nil, err }
-    in, err := ort.NewEmptyTensor[float32](ort.NewShape(1, 3, inH, inW))
-    if err != nil { return nil, err }
-    out, err := ort.NewEmptyTensor[float32](ort.NewShape(1, nDigits, 10))
-    if err != nil { in.Destroy(); return nil, err }
-    sess, err := ort.NewSession[float32](modelPath,
-        []string{"input"}, []string{"logits"},
-        []*ort.Tensor[float32]{in}, []*ort.Tensor[float32]{out})
-    if err != nil { in.Destroy(); out.Destroy(); return nil, err }
-    return &Solver{sess, in, out}, nil
-}
-
-func (s *Solver) Solve(png []byte) (string, error) {
-    src, _, err := image.Decode(bytes.NewReader(png))
-    if err != nil { return "", err }
-    dst := image.NewRGBA(image.Rect(0, 0, inW, inH))
-    draw.ApproxBiLinear.Scale(dst, dst.Bounds(), src, src.Bounds(), draw.Over, nil)
-
-    data := s.in.GetData()
-    idx := 0
-    // NCHW layout: all R, then all G, then all B
-    for y := 0; y < inH; y++ { for x := 0; x < inW; x++ { r,_,_,_ := dst.At(x,y).RGBA(); data[idx]=float32(r>>8)/255; idx++ } }
-    for y := 0; y < inH; y++ { for x := 0; x < inW; x++ { _,g,_,_ := dst.At(x,y).RGBA(); data[idx]=float32(g>>8)/255; idx++ } }
-    for y := 0; y < inH; y++ { for x := 0; x < inW; x++ { _,_,b,_ := dst.At(x,y).RGBA(); data[idx]=float32(b>>8)/255; idx++ } }
-
-    if err := s.sess.Run(); err != nil { return "", err }
-    got := s.out.GetData()
-    code := make([]byte, nDigits)
-    for p := 0; p < nDigits; p++ {
-        best := 0
-        for c := 1; c < 10; c++ { if got[p*10+c] > got[p*10+best] { best = c } }
-        code[p] = '0' + byte(best)
-    }
-    return string(code), nil
-}
-```
-
-> Note: `onnxruntime_go.NewSession` reads the model from a file. If you embed it with
-> `go:embed`, use `NewSessionWithONNXData` with the bytes instead.
-
-### Performance
-
-- Single inference: ~5-15ms (CPU, M1/modern x86)
-- Full flow (load + preprocess + infer): ~10-30ms
-- No GPU needed, memory < 50MB
-
----

docs/TRAINING.md

@@ -1,181 +0,0 @@
-# 训练与微调 / Training & Fine-tuning
-
----
-
-## 中文
-
-### 环境
-
-```bash
-pip install torch onnx onnxscript pillow numpy opencv-python
-```
-
-### 从零训练
-
-**1. 准备数据**
-
-标签格式 `labels.json`：
-```json
-{
-  "captcha_001.png": {"label": "4821"},
-  "captcha_002.png": {"label": "9037"}
-}
-```
-
-图片目录：150x60 左右的 RGB 验证码 PNG，文件名与标签键一致。
-
-**2. 训练**
-
-```bash
-python scripts/train_fixed.py \
-  <labels.json> <图片目录> <输出.onnx> \
-  0.08      # val 比例
-  500       # epochs
-  1         # 增强开关 (1=开)
-  rgb       # 输入 RGB (关键: 不要用灰度)
-```
-
-示例：
-```bash
-python scripts/train_fixed.py \
-  data/1000_labels.json data/1000_raw \
-  models/my_model.onnx \
-  0.08 500 1 rgb
-```
-
-产物：
-- `<输出>.onnx` — 最终 ONNX 模型
-- `<输出>.onnx.pt` — 最优 epoch 的 PyTorch 权重 (best val)
-
-**3. 推理验证**
-
-```python
-import numpy as np, onnxruntime as ort
-from PIL import Image
-sess = ort.InferenceSession("my_model.onnx", providers=["CPUExecutionProvider"])
-im = Image.open("captcha.png").convert("RGB").resize((160,64), Image.BILINEAR)
-x = np.asarray(im, dtype=np.float32).transpose(2,0,1)[None] / 255.0
-logits = sess.run(None, {"input": x})[0]
-code = "".join(str(int(logits[0,p].argmax())) for p in range(4))
-```
-
-### 微调 (Fine-tune)
-
-从 checkpoint 续训（`train_fixed.py` 检测到 `<输出>.onnx.pt` 存在会自动加载权重）：
-
-```bash
-cp models/captcha_1000_raw.onnx.pt models/finetuned.onnx.pt
-python scripts/train_fixed.py <新标签.json> <新图目录> models/finetuned.onnx 0.08 200 1 rgb
-```
-
-- 只标少量新样本（50-200 张）即可适配小幅变化
-- 生成器变化大时建议新旧数据混合训练，避免灾难性遗忘
-- 保持同样的预处理（RGB 160x64 /255，不去噪）和增强配置
-
-### 参数说明
-
-| 参数 | 默认 | 说明 |
-|---|---|---|
-| val_frac | 0.1 | 验证集比例 |
-| epochs | 400 | 总训练轮数 |
-| aug | 1 | 增强开关 |
-| rgb | - | 传 `rgb` 启用 3 通道输入（推荐） |
-
-### 关键经验（踩过的坑）
-
-1. **必须用 RGB，不要灰度** — 验证码数字是彩色的，灰度丢信息。
-2. **不要图像去噪** — 形态学开运算砍掉细笔画，val 从 88.6% 掉到 79.8%。数据量足够时模型自己学会过滤干扰线。
-3. **位置保留架构，不要 Global Average Pooling** — GAP 丢空间位置导致 val 归零；按列分组池化（20列→4位置）后立即泛化。
-4. **人类标注 >> 视觉模型自动标注** — 自动标注 ~35% 噪声会把模型带崩到 0% 命中；手工 100% 干净标签才能学到真实分布。
-5. **增强不要加高斯噪声** — 验证码本身有干扰线，再加随机噪声会让训练样本面目全非。
-
----
-
-## English
-
-### Environment
-
-```bash
-pip install torch onnx onnxscript pillow numpy opencv-python
-```
-
-### Training from scratch
-
-**1. Prepare data**
-
-Label format `labels.json`:
-```json
-{
-  "captcha_001.png": {"label": "4821"},
-  "captcha_002.png": {"label": "9037"}
-}
-```
-
-Image dir: ~150x60 RGB captcha PNGs; filenames must match label keys.
-
-**2. Train**
-
-```bash
-python scripts/train_fixed.py \
-  <labels.json> <image_dir> <output.onnx> \
-  0.08      # val fraction
-  500       # epochs
-  1         # augmentation on/off (1=on)
-  rgb       # RGB input (important: do NOT use grayscale)
-```
-
-Example:
-```bash
-python scripts/train_fixed.py \
-  data/1000_labels.json data/1000_raw \
-  models/my_model.onnx \
-  0.08 500 1 rgb
-```
-
-Outputs:
-- `<output>.onnx` — final ONNX model
-- `<output>.onnx.pt` — best-epoch PyTorch weights
-
-**3. Verify inference**
-
-```python
-import numpy as np, onnxruntime as ort
-from PIL import Image
-sess = ort.InferenceSession("my_model.onnx", providers=["CPUExecutionProvider"])
-im = Image.open("captcha.png").convert("RGB").resize((160,64), Image.BILINEAR)
-x = np.asarray(im, dtype=np.float32).transpose(2,0,1)[None] / 255.0
-logits = sess.run(None, {"input": x})[0]
-code = "".join(str(int(logits[0,p].argmax())) for p in range(4))
-```
-
-### Fine-tuning
-
-`train_fixed.py` auto-loads an existing `<output>.onnx.pt` and resumes from it:
-
-```bash
-cp models/captcha_1000_raw.onnx.pt models/finetuned.onnx.pt
-python scripts/train_fixed.py <new_labels.json> <new_image_dir> models/finetuned.onnx 0.08 200 1 rgb
-```
-
-- 50-200 new labeled samples are enough for small changes.
-- Mix old + new data when the generator changes a lot, to avoid catastrophic forgetting.
-- Keep the same preprocessing (RGB 160x64 /255, no denoise) and augmentation.
-
-### Parameters
-
-| Param | Default | Description |
-|---|---|---|
-| val_frac | 0.1 | validation fraction |
-| epochs | 400 | total epochs |
-| aug | 1 | augmentation toggle |
-| rgb | - | pass `rgb` for 3-channel input (recommended) |
-
-### Key lessons
-
-1. **Use RGB, not grayscale** — the digits are colored; grayscale loses information.
-2. **Do NOT denoise** — morphological opening removes thin strokes, dropping val from 88.6% to 79.8%. With enough data the model learns to ignore noise lines itself.
-3. **Position-preserving architecture, never global average pooling** — GAP destroys spatial position (val → 0%); per-column grouped pooling (20 cols → 4 positions) restores generalization.
-4. **Human labels >> auto vision labels** — auto labels with ~35% noise crashed the model to 0%; clean manual labels are essential.
-5. **No Gaussian noise augmentation** — the captcha already has noise lines; adding more obscures the training signal.
-
----